libc

package module

Go to main page

Versions in this module

v0

v0.0.6

May 18, 2023

v0.0.5

May 18, 2023

v0.0.4

May 18, 2023

v0.0.3

May 17, 2023

v0.0.2

May 17, 2023

v0.0.1

May 17, 2023

Changes in this version

+ const DT_DETACHED — linux/amd64, windows/amd64

+ const DT_EXITING — linux/amd64, windows/amd64

+ const DT_JOINABLE — linux/amd64, windows/amd64

+ var CAPI = map[string]struct — darwin/amd64, linux/amd64, windows/amd64

+ var Covered = map[uintptr]struct{}

+ var CoveredC = map[string]struct{}

+ var EBADF = errors.New("EBADF") — windows/amd64

+ var SecToUnixEpoch int64 = 11644473600 — windows/amd64

+ var Windows_Tick int64 = 10000000 — windows/amd64

+ var X_CurrentRuneLocale uintptr = 0 — darwin/amd64

+ var X_DefaultRuneLocale = _RuneLocale — darwin/amd64

+ var X__darwin_check_fd_set_overflow uintptr — darwin/amd64

+ var X__fsmu8 = [51]uint32_t — linux/amd64

+ var X__imp__environ = EnvironP() — windows/amd64

+ var X__imp__wenviron = uintptr(unsafe.Pointer(&wenviron)) — windows/amd64

+ var X__mb_cur_max int32 = 1 — darwin/amd64

+ var X__stderrp = Xstdout — darwin/amd64

+ var X__stdinp = Xstdin — darwin/amd64

+ var X__stdoutp = Xstdout — darwin/amd64

+ var X_imp___environ = EnvironP() — windows/amd64

+ var X_iob [stdio.X_IOB_ENTRIES]stdio.FILE — windows/amd64

+ var Xenviron uintptr

+ var Xh_errno int32 — darwin/amd64, linux/amd64

+ var Xstderr = newFile(nil, unistd.STDERR_FILENO)

+ var Xstdin = newFile(nil, unistd.STDIN_FILENO)

+ var Xstdout = newFile(nil, unistd.STDOUT_FILENO)

+ var Xtimezone long — windows/amd64

+ var Xzero_struct_address address — darwin/amd64, linux/amd64

+ func AssignAddComplex128(p *complex128, v complex128) complex128

+ func AssignAddComplex64(p *complex64, v complex64) complex64

+ func AssignAddFloat32(p *float32, v float32) float32

+ func AssignAddFloat64(p *float64, v float64) float64

+ func AssignAddInt16(p *int16, v int16) int16

+ func AssignAddInt32(p *int32, v int32) int32

+ func AssignAddInt64(p *int64, v int64) int64

+ func AssignAddInt8(p *int8, v int8) int8

+ func AssignAddPtrComplex128(p uintptr, v complex128) complex128

+ func AssignAddPtrComplex64(p uintptr, v complex64) complex64

+ func AssignAddPtrFloat32(p uintptr, v float32) float32

+ func AssignAddPtrFloat64(p uintptr, v float64) float64

+ func AssignAddPtrInt16(p uintptr, v int16) int16

+ func AssignAddPtrInt32(p uintptr, v int32) int32

+ func AssignAddPtrInt64(p uintptr, v int64) int64

+ func AssignAddPtrInt8(p uintptr, v int8) int8

+ func AssignAddPtrUint16(p uintptr, v uint16) uint16

+ func AssignAddPtrUint32(p uintptr, v uint32) uint32

+ func AssignAddPtrUint64(p uintptr, v uint64) uint64

+ func AssignAddPtrUint8(p uintptr, v uint8) uint8

+ func AssignAddPtrUintptr(p uintptr, v uintptr) uintptr

+ func AssignAddUint16(p *uint16, v uint16) uint16

+ func AssignAddUint32(p *uint32, v uint32) uint32

+ func AssignAddUint64(p *uint64, v uint64) uint64

+ func AssignAddUint8(p *uint8, v uint8) uint8

+ func AssignAddUintptr(p *uintptr, v uintptr) uintptr

+ func AssignAndInt16(p *int16, v int16) int16

+ func AssignAndInt32(p *int32, v int32) int32

+ func AssignAndInt64(p *int64, v int64) int64

+ func AssignAndInt8(p *int8, v int8) int8

+ func AssignAndPtrInt16(p uintptr, v int16) int16

+ func AssignAndPtrInt32(p uintptr, v int32) int32

+ func AssignAndPtrInt64(p uintptr, v int64) int64

+ func AssignAndPtrInt8(p uintptr, v int8) int8

+ func AssignAndPtrUint16(p uintptr, v uint16) uint16

+ func AssignAndPtrUint32(p uintptr, v uint32) uint32

+ func AssignAndPtrUint64(p uintptr, v uint64) uint64

+ func AssignAndPtrUint8(p uintptr, v uint8) uint8

+ func AssignAndPtrUintptr(p uintptr, v uintptr) uintptr

+ func AssignAndUint16(p *uint16, v uint16) uint16

+ func AssignAndUint32(p *uint32, v uint32) uint32

+ func AssignAndUint64(p *uint64, v uint64) uint64

+ func AssignAndUint8(p *uint8, v uint8) uint8

+ func AssignAndUintptr(p *uintptr, v uintptr) uintptr

+ func AssignBitFieldPtr16Int16(p uintptr, v int16, w, off int, mask uint16) int16

+ func AssignBitFieldPtr16Int32(p uintptr, v int32, w, off int, mask uint16) int32

+ func AssignBitFieldPtr16Int64(p uintptr, v int64, w, off int, mask uint16) int64

+ func AssignBitFieldPtr16Int8(p uintptr, v int8, w, off int, mask uint16) int8

+ func AssignBitFieldPtr16Uint16(p uintptr, v uint16, w, off int, mask uint16) uint16

+ func AssignBitFieldPtr16Uint32(p uintptr, v uint32, w, off int, mask uint16) uint32

+ func AssignBitFieldPtr16Uint64(p uintptr, v uint64, w, off int, mask uint16) uint64

+ func AssignBitFieldPtr16Uint8(p uintptr, v uint8, w, off int, mask uint16) uint8

+ func AssignBitFieldPtr32Int16(p uintptr, v int16, w, off int, mask uint32) int16

+ func AssignBitFieldPtr32Int32(p uintptr, v int32, w, off int, mask uint32) int32

+ func AssignBitFieldPtr32Int64(p uintptr, v int64, w, off int, mask uint32) int64

+ func AssignBitFieldPtr32Int8(p uintptr, v int8, w, off int, mask uint32) int8

+ func AssignBitFieldPtr32Uint16(p uintptr, v uint16, w, off int, mask uint32) uint16

+ func AssignBitFieldPtr32Uint32(p uintptr, v uint32, w, off int, mask uint32) uint32

+ func AssignBitFieldPtr32Uint64(p uintptr, v uint64, w, off int, mask uint32) uint64

+ func AssignBitFieldPtr32Uint8(p uintptr, v uint8, w, off int, mask uint32) uint8

+ func AssignBitFieldPtr64Int16(p uintptr, v int16, w, off int, mask uint64) int16

+ func AssignBitFieldPtr64Int32(p uintptr, v int32, w, off int, mask uint64) int32

+ func AssignBitFieldPtr64Int64(p uintptr, v int64, w, off int, mask uint64) int64

+ func AssignBitFieldPtr64Int8(p uintptr, v int8, w, off int, mask uint64) int8

+ func AssignBitFieldPtr64Uint16(p uintptr, v uint16, w, off int, mask uint64) uint16

+ func AssignBitFieldPtr64Uint32(p uintptr, v uint32, w, off int, mask uint64) uint32

+ func AssignBitFieldPtr64Uint64(p uintptr, v uint64, w, off int, mask uint64) uint64

+ func AssignBitFieldPtr64Uint8(p uintptr, v uint8, w, off int, mask uint64) uint8

+ func AssignBitFieldPtr8Int16(p uintptr, v int16, w, off int, mask uint8) int16

+ func AssignBitFieldPtr8Int32(p uintptr, v int32, w, off int, mask uint8) int32

+ func AssignBitFieldPtr8Int64(p uintptr, v int64, w, off int, mask uint8) int64

+ func AssignBitFieldPtr8Int8(p uintptr, v int8, w, off int, mask uint8) int8

+ func AssignBitFieldPtr8Uint16(p uintptr, v uint16, w, off int, mask uint8) uint16

+ func AssignBitFieldPtr8Uint32(p uintptr, v uint32, w, off int, mask uint8) uint32

+ func AssignBitFieldPtr8Uint64(p uintptr, v uint64, w, off int, mask uint8) uint64

+ func AssignBitFieldPtr8Uint8(p uintptr, v uint8, w, off int, mask uint8) uint8

+ func AssignComplex128(p *complex128, v complex128) complex128

+ func AssignComplex64(p *complex64, v complex64) complex64

+ func AssignDivComplex128(p *complex128, v complex128) complex128

+ func AssignDivComplex64(p *complex64, v complex64) complex64

+ func AssignDivFloat32(p *float32, v float32) float32

+ func AssignDivFloat64(p *float64, v float64) float64

+ func AssignDivInt16(p *int16, v int16) int16

+ func AssignDivInt32(p *int32, v int32) int32

+ func AssignDivInt64(p *int64, v int64) int64

+ func AssignDivInt8(p *int8, v int8) int8

+ func AssignDivPtrComplex128(p uintptr, v complex128) complex128

+ func AssignDivPtrComplex64(p uintptr, v complex64) complex64

+ func AssignDivPtrFloat32(p uintptr, v float32) float32

+ func AssignDivPtrFloat64(p uintptr, v float64) float64

+ func AssignDivPtrInt16(p uintptr, v int16) int16

+ func AssignDivPtrInt32(p uintptr, v int32) int32

+ func AssignDivPtrInt64(p uintptr, v int64) int64

+ func AssignDivPtrInt8(p uintptr, v int8) int8

+ func AssignDivPtrUint16(p uintptr, v uint16) uint16

+ func AssignDivPtrUint32(p uintptr, v uint32) uint32

+ func AssignDivPtrUint64(p uintptr, v uint64) uint64

+ func AssignDivPtrUint8(p uintptr, v uint8) uint8

+ func AssignDivPtrUintptr(p uintptr, v uintptr) uintptr

+ func AssignDivUint16(p *uint16, v uint16) uint16

+ func AssignDivUint32(p *uint32, v uint32) uint32

+ func AssignDivUint64(p *uint64, v uint64) uint64

+ func AssignDivUint8(p *uint8, v uint8) uint8

+ func AssignDivUintptr(p *uintptr, v uintptr) uintptr

+ func AssignFloat32(p *float32, v float32) float32

+ func AssignFloat64(p *float64, v float64) float64

+ func AssignInt16(p *int16, v int16) int16

+ func AssignInt32(p *int32, v int32) int32

+ func AssignInt64(p *int64, v int64) int64

+ func AssignInt8(p *int8, v int8) int8

+ func AssignMulComplex128(p *complex128, v complex128) complex128

+ func AssignMulComplex64(p *complex64, v complex64) complex64

+ func AssignMulFloat32(p *float32, v float32) float32

+ func AssignMulFloat64(p *float64, v float64) float64

+ func AssignMulInt16(p *int16, v int16) int16

+ func AssignMulInt32(p *int32, v int32) int32

+ func AssignMulInt64(p *int64, v int64) int64

+ func AssignMulInt8(p *int8, v int8) int8

+ func AssignMulPtrComplex128(p uintptr, v complex128) complex128

+ func AssignMulPtrComplex64(p uintptr, v complex64) complex64

+ func AssignMulPtrFloat32(p uintptr, v float32) float32

+ func AssignMulPtrFloat64(p uintptr, v float64) float64

+ func AssignMulPtrInt16(p uintptr, v int16) int16

+ func AssignMulPtrInt32(p uintptr, v int32) int32

+ func AssignMulPtrInt64(p uintptr, v int64) int64

+ func AssignMulPtrInt8(p uintptr, v int8) int8

+ func AssignMulPtrUint16(p uintptr, v uint16) uint16

+ func AssignMulPtrUint32(p uintptr, v uint32) uint32

+ func AssignMulPtrUint64(p uintptr, v uint64) uint64

+ func AssignMulPtrUint8(p uintptr, v uint8) uint8

+ func AssignMulPtrUintptr(p uintptr, v uintptr) uintptr

+ func AssignMulUint16(p *uint16, v uint16) uint16

+ func AssignMulUint32(p *uint32, v uint32) uint32

+ func AssignMulUint64(p *uint64, v uint64) uint64

+ func AssignMulUint8(p *uint8, v uint8) uint8

+ func AssignMulUintptr(p *uintptr, v uintptr) uintptr

+ func AssignOrInt16(p *int16, v int16) int16

+ func AssignOrInt32(p *int32, v int32) int32

+ func AssignOrInt64(p *int64, v int64) int64

+ func AssignOrInt8(p *int8, v int8) int8

+ func AssignOrPtrInt16(p uintptr, v int16) int16

+ func AssignOrPtrInt32(p uintptr, v int32) int32

+ func AssignOrPtrInt64(p uintptr, v int64) int64

+ func AssignOrPtrInt8(p uintptr, v int8) int8

+ func AssignOrPtrUint16(p uintptr, v uint16) uint16

+ func AssignOrPtrUint32(p uintptr, v uint32) uint32

+ func AssignOrPtrUint64(p uintptr, v uint64) uint64

+ func AssignOrPtrUint8(p uintptr, v uint8) uint8

+ func AssignOrPtrUintptr(p uintptr, v uintptr) uintptr

+ func AssignOrUint16(p *uint16, v uint16) uint16

+ func AssignOrUint32(p *uint32, v uint32) uint32

+ func AssignOrUint64(p *uint64, v uint64) uint64

+ func AssignOrUint8(p *uint8, v uint8) uint8

+ func AssignOrUintptr(p *uintptr, v uintptr) uintptr

+ func AssignPtrComplex128(p uintptr, v complex128) complex128

+ func AssignPtrComplex64(p uintptr, v complex64) complex64

+ func AssignPtrFloat32(p uintptr, v float32) float32

+ func AssignPtrFloat64(p uintptr, v float64) float64

+ func AssignPtrInt16(p uintptr, v int16) int16

+ func AssignPtrInt32(p uintptr, v int32) int32

+ func AssignPtrInt64(p uintptr, v int64) int64

+ func AssignPtrInt8(p uintptr, v int8) int8

+ func AssignPtrUint16(p uintptr, v uint16) uint16

+ func AssignPtrUint32(p uintptr, v uint32) uint32

+ func AssignPtrUint64(p uintptr, v uint64) uint64

+ func AssignPtrUint8(p uintptr, v uint8) uint8

+ func AssignPtrUintptr(p uintptr, v uintptr) uintptr

+ func AssignRemInt16(p *int16, v int16) int16

+ func AssignRemInt32(p *int32, v int32) int32

+ func AssignRemInt64(p *int64, v int64) int64

+ func AssignRemInt8(p *int8, v int8) int8

+ func AssignRemPtrInt16(p uintptr, v int16) int16

+ func AssignRemPtrInt32(p uintptr, v int32) int32

+ func AssignRemPtrInt64(p uintptr, v int64) int64

+ func AssignRemPtrInt8(p uintptr, v int8) int8

+ func AssignRemPtrUint16(p uintptr, v uint16) uint16

+ func AssignRemPtrUint32(p uintptr, v uint32) uint32

+ func AssignRemPtrUint64(p uintptr, v uint64) uint64

+ func AssignRemPtrUint8(p uintptr, v uint8) uint8

+ func AssignRemPtrUintptr(p uintptr, v uintptr) uintptr

+ func AssignRemUint16(p *uint16, v uint16) uint16

+ func AssignRemUint32(p *uint32, v uint32) uint32

+ func AssignRemUint64(p *uint64, v uint64) uint64

+ func AssignRemUint8(p *uint8, v uint8) uint8

+ func AssignRemUintptr(p *uintptr, v uintptr) uintptr

+ func AssignShlInt16(p *int16, v int) int16

+ func AssignShlInt32(p *int32, v int) int32

+ func AssignShlInt64(p *int64, v int) int64

+ func AssignShlInt8(p *int8, v int) int8

+ func AssignShlPtrInt16(p uintptr, v int) int16

+ func AssignShlPtrInt32(p uintptr, v int) int32

+ func AssignShlPtrInt64(p uintptr, v int) int64

+ func AssignShlPtrInt8(p uintptr, v int) int8

+ func AssignShlPtrUint16(p uintptr, v int) uint16

+ func AssignShlPtrUint32(p uintptr, v int) uint32

+ func AssignShlPtrUint64(p uintptr, v int) uint64

+ func AssignShlPtrUint8(p uintptr, v int) uint8

+ func AssignShlPtrUintptr(p uintptr, v int) uintptr

+ func AssignShlUint16(p *uint16, v int) uint16

+ func AssignShlUint32(p *uint32, v int) uint32

+ func AssignShlUint64(p *uint64, v int) uint64

+ func AssignShlUint8(p *uint8, v int) uint8

+ func AssignShlUintptr(p *uintptr, v int) uintptr

+ func AssignShrInt16(p *int16, v int) int16

+ func AssignShrInt32(p *int32, v int) int32

+ func AssignShrInt64(p *int64, v int) int64

+ func AssignShrInt8(p *int8, v int) int8

+ func AssignShrPtrInt16(p uintptr, v int) int16

+ func AssignShrPtrInt32(p uintptr, v int) int32

+ func AssignShrPtrInt64(p uintptr, v int) int64

+ func AssignShrPtrInt8(p uintptr, v int) int8

+ func AssignShrPtrUint16(p uintptr, v int) uint16

+ func AssignShrPtrUint32(p uintptr, v int) uint32

+ func AssignShrPtrUint64(p uintptr, v int) uint64

+ func AssignShrPtrUint8(p uintptr, v int) uint8

+ func AssignShrPtrUintptr(p uintptr, v int) uintptr

+ func AssignShrUint16(p *uint16, v int) uint16

+ func AssignShrUint32(p *uint32, v int) uint32

+ func AssignShrUint64(p *uint64, v int) uint64

+ func AssignShrUint8(p *uint8, v int) uint8

+ func AssignShrUintptr(p *uintptr, v int) uintptr

+ func AssignSubComplex128(p *complex128, v complex128) complex128

+ func AssignSubComplex64(p *complex64, v complex64) complex64

+ func AssignSubFloat32(p *float32, v float32) float32

+ func AssignSubFloat64(p *float64, v float64) float64

+ func AssignSubInt16(p *int16, v int16) int16

+ func AssignSubInt32(p *int32, v int32) int32

+ func AssignSubInt64(p *int64, v int64) int64

+ func AssignSubInt8(p *int8, v int8) int8

+ func AssignSubPtrComplex128(p uintptr, v complex128) complex128

+ func AssignSubPtrComplex64(p uintptr, v complex64) complex64

+ func AssignSubPtrFloat32(p uintptr, v float32) float32

+ func AssignSubPtrFloat64(p uintptr, v float64) float64

+ func AssignSubPtrInt16(p uintptr, v int16) int16

+ func AssignSubPtrInt32(p uintptr, v int32) int32

+ func AssignSubPtrInt64(p uintptr, v int64) int64

+ func AssignSubPtrInt8(p uintptr, v int8) int8

+ func AssignSubPtrUint16(p uintptr, v uint16) uint16

+ func AssignSubPtrUint32(p uintptr, v uint32) uint32

+ func AssignSubPtrUint64(p uintptr, v uint64) uint64

+ func AssignSubPtrUint8(p uintptr, v uint8) uint8

+ func AssignSubPtrUintptr(p uintptr, v uintptr) uintptr

+ func AssignSubUint16(p *uint16, v uint16) uint16

+ func AssignSubUint32(p *uint32, v uint32) uint32

+ func AssignSubUint64(p *uint64, v uint64) uint64

+ func AssignSubUint8(p *uint8, v uint8) uint8

+ func AssignSubUintptr(p *uintptr, v uintptr) uintptr

+ func AssignUint16(p *uint16, v uint16) uint16

+ func AssignUint32(p *uint32, v uint32) uint32

+ func AssignUint64(p *uint64, v uint64) uint64

+ func AssignUint8(p *uint8, v uint8) uint8

+ func AssignUintptr(p *uintptr, v uintptr) uintptr

+ func AssignXorInt16(p *int16, v int16) int16

+ func AssignXorInt32(p *int32, v int32) int32

+ func AssignXorInt64(p *int64, v int64) int64

+ func AssignXorInt8(p *int8, v int8) int8

+ func AssignXorPtrInt16(p uintptr, v int16) int16

+ func AssignXorPtrInt32(p uintptr, v int32) int32

+ func AssignXorPtrInt64(p uintptr, v int64) int64

+ func AssignXorPtrInt8(p uintptr, v int8) int8

+ func AssignXorPtrUint16(p uintptr, v uint16) uint16

+ func AssignXorPtrUint32(p uintptr, v uint32) uint32

+ func AssignXorPtrUint64(p uintptr, v uint64) uint64

+ func AssignXorPtrUint8(p uintptr, v uint8) uint8

+ func AssignXorPtrUintptr(p uintptr, v uintptr) uintptr

+ func AssignXorUint16(p *uint16, v uint16) uint16

+ func AssignXorUint32(p *uint32, v uint32) uint32

+ func AssignXorUint64(p *uint64, v uint64) uint64

+ func AssignXorUint8(p *uint8, v uint8) uint8

+ func AssignXorUintptr(p *uintptr, v uintptr) uintptr

+ func AtExit(f func())

+ func AtomicAddFloat32(addr *float32, delta float32) (new float32)

+ func AtomicAddFloat64(addr *float64, delta float64) (new float64)

+ func AtomicAddInt32(addr *int32, delta int32) (new int32)

+ func AtomicAddInt64(addr *int64, delta int64) (new int64)

+ func AtomicAddUint32(addr *uint32, delta uint32) (new uint32)

+ func AtomicAddUint64(addr *uint64, delta uint64) (new uint64)

+ func AtomicAddUintptr(addr *uintptr, delta uintptr) (new uintptr)

+ func AtomicLoadFloat32(addr *float32) (val float32)

+ func AtomicLoadFloat64(addr *float64) (val float64)

+ func AtomicLoadInt32(addr *int32) (val int32)

+ func AtomicLoadInt64(addr *int64) (val int64)

+ func AtomicLoadNInt32(ptr uintptr, memorder int32) int32

+ func AtomicLoadNInt64(ptr uintptr, memorder int32) int64

+ func AtomicLoadNUint16(ptr uintptr, memorder int32) uint16

+ func AtomicLoadNUint32(ptr uintptr, memorder int32) uint32

+ func AtomicLoadNUint64(ptr uintptr, memorder int32) uint64

+ func AtomicLoadNUintptr(ptr uintptr, memorder int32) uintptr

+ func AtomicLoadPFloat32(addr uintptr) (val float32)

+ func AtomicLoadPFloat64(addr uintptr) (val float64)

+ func AtomicLoadPInt32(addr uintptr) (val int32)

+ func AtomicLoadPInt64(addr uintptr) (val int64)

+ func AtomicLoadPUint32(addr uintptr) (val uint32)

+ func AtomicLoadPUint64(addr uintptr) (val uint64)

+ func AtomicLoadPUintptr(addr uintptr) (val uintptr)

+ func AtomicLoadUint32(addr *uint32) (val uint32)

+ func AtomicLoadUint64(addr *uint64) (val uint64)

+ func AtomicLoadUintptr(addr *uintptr) (val uintptr)

+ func AtomicStoreFloat32(addr *float32, val float32)

+ func AtomicStoreFloat64(addr *float64, val float64)

+ func AtomicStoreInt32(addr *int32, val int32)

+ func AtomicStoreInt64(addr *int64, val int64)

+ func AtomicStoreNInt32(ptr uintptr, val int32, memorder int32)

+ func AtomicStoreNInt64(ptr uintptr, val int64, memorder int32)

+ func AtomicStoreNUint16(ptr uintptr, val uint16, memorder int32)

+ func AtomicStoreNUint32(ptr uintptr, val uint32, memorder int32)

+ func AtomicStoreNUint64(ptr uintptr, val uint64, memorder int32)

+ func AtomicStoreNUintptr(ptr uintptr, val uintptr, memorder int32)

+ func AtomicStorePFloat32(addr uintptr, val float32)

+ func AtomicStorePFloat64(addr uintptr, val float64)

+ func AtomicStorePInt32(addr uintptr, val int32)

+ func AtomicStorePInt64(addr uintptr, val int64)

+ func AtomicStorePUint32(addr uintptr, val uint32)

+ func AtomicStorePUint64(addr uintptr, val uint64)

+ func AtomicStorePUintptr(addr uintptr, val uintptr)

+ func AtomicStoreUint32(addr *uint32, val uint32)

+ func AtomicStoreUint64(addr *uint64, val uint64)

+ func AtomicStoreUintptr(addr *uintptr, val uintptr)

+ func Bool32(b bool) int32

+ func Bool64(b bool) int64

+ func BoolInt16(b bool) int16

+ func BoolInt32(b bool) int32

+ func BoolInt64(b bool) int64

+ func BoolInt8(b bool) int8

+ func BoolUint16(b bool) uint16

+ func BoolUint32(b bool) uint32

+ func BoolUint64(b bool) uint64

+ func BoolUint8(b bool) uint8

+ func BoolUintptr(b bool) uintptr

+ func CString(s string) (uintptr, error)

+ func Complex128(n complex128) complex128

+ func Complex128FromComplex128(n complex128) complex128

+ func Complex128FromComplex64(n complex64) complex128

+ func Complex128FromFloat32(n float32) complex128

+ func Complex128FromFloat64(n float64) complex128

+ func Complex128FromInt16(n int16) complex128

+ func Complex128FromInt32(n int32) complex128

+ func Complex128FromInt64(n int64) complex128

+ func Complex128FromInt8(n int8) complex128

+ func Complex128FromUint16(n uint16) complex128

+ func Complex128FromUint32(n uint32) complex128

+ func Complex128FromUint64(n uint64) complex128

+ func Complex128FromUint8(n uint8) complex128

+ func Complex128FromUintptr(n uintptr) complex128

+ func Complex64(n complex64) complex64

+ func Complex64FromComplex128(n complex128) complex64

+ func Complex64FromComplex64(n complex64) complex64

+ func Complex64FromFloat32(n float32) complex64

+ func Complex64FromFloat64(n float64) complex64

+ func Complex64FromInt16(n int16) complex64

+ func Complex64FromInt32(n int32) complex64

+ func Complex64FromInt64(n int64) complex64

+ func Complex64FromInt8(n int8) complex64

+ func Complex64FromUint16(n uint16) complex64

+ func Complex64FromUint32(n uint32) complex64

+ func Complex64FromUint64(n uint64) complex64

+ func Complex64FromUint8(n uint8) complex64

+ func Complex64FromUintptr(n uintptr) complex64

+ func Cover()

+ func CoverC(s string)

+ func CoverCReport(w io.Writer) error

+ func CoverReport(w io.Writer) error

+ func CplInt16(n int16) int16

+ func CplInt32(n int32) int32

+ func CplInt64(n int64) int64

+ func CplInt8(n int8) int8

+ func CplUint16(n uint16) uint16

+ func CplUint32(n uint32) uint32

+ func CplUint64(n uint64) uint64

+ func CplUint8(n uint8) uint8

+ func CplUintptr(n uintptr) uintptr

+ func Dmesg(s string, args ...interface{})

+ func Environ() uintptr

+ func EnvironP() uintptr

+ func Float32(n float32) float32

+ func Float32FromComplex128(n complex128) float32

+ func Float32FromComplex64(n complex64) float32

+ func Float32FromFloat32(n float32) float32

+ func Float32FromFloat64(n float64) float32

+ func Float32FromInt16(n int16) float32

+ func Float32FromInt32(n int32) float32

+ func Float32FromInt64(n int64) float32

+ func Float32FromInt8(n int8) float32

+ func Float32FromUint16(n uint16) float32

+ func Float32FromUint32(n uint32) float32

+ func Float32FromUint64(n uint64) float32

+ func Float32FromUint8(n uint8) float32

+ func Float32FromUintptr(n uintptr) float32

+ func Float64(n float64) float64

+ func Float64FromComplex128(n complex128) float64

+ func Float64FromComplex64(n complex64) float64

+ func Float64FromFloat32(n float32) float64

+ func Float64FromFloat64(n float64) float64

+ func Float64FromInt16(n int16) float64

+ func Float64FromInt32(n int32) float64

+ func Float64FromInt64(n int64) float64

+ func Float64FromInt8(n int8) float64

+ func Float64FromUint16(n uint16) float64

+ func Float64FromUint32(n uint32) float64

+ func Float64FromUint64(n uint64) float64

+ func Float64FromUint8(n uint8) float64

+ func Float64FromUintptr(n uintptr) float64

+ func GetEnviron() (r []string)

+ func GoBytes(s uintptr, len int) []byte

+ func GoString(s uintptr) string

+ func Int16(n int16) int16

+ func Int16FromComplex128(n complex128) int16

+ func Int16FromComplex64(n complex64) int16

+ func Int16FromFloat32(n float32) int16

+ func Int16FromFloat64(n float64) int16

+ func Int16FromInt16(n int16) int16

+ func Int16FromInt32(n int32) int16

+ func Int16FromInt64(n int64) int16

+ func Int16FromInt8(n int8) int16

+ func Int16FromUint16(n uint16) int16

+ func Int16FromUint32(n uint32) int16

+ func Int16FromUint64(n uint64) int16

+ func Int16FromUint8(n uint8) int16

+ func Int16FromUintptr(n uintptr) int16

+ func Int32(n int32) int32

+ func Int32FromComplex128(n complex128) int32

+ func Int32FromComplex64(n complex64) int32

+ func Int32FromFloat32(n float32) int32

+ func Int32FromFloat64(n float64) int32

+ func Int32FromInt16(n int16) int32

+ func Int32FromInt32(n int32) int32

+ func Int32FromInt64(n int64) int32

+ func Int32FromInt8(n int8) int32

+ func Int32FromUint16(n uint16) int32

+ func Int32FromUint32(n uint32) int32

+ func Int32FromUint64(n uint64) int32

+ func Int32FromUint8(n uint8) int32

+ func Int32FromUintptr(n uintptr) int32

+ func Int64(n int64) int64

+ func Int64FromComplex128(n complex128) int64

+ func Int64FromComplex64(n complex64) int64

+ func Int64FromFloat32(n float32) int64

+ func Int64FromFloat64(n float64) int64

+ func Int64FromInt16(n int16) int64

+ func Int64FromInt32(n int32) int64

+ func Int64FromInt64(n int64) int64

+ func Int64FromInt8(n int8) int64

+ func Int64FromUint16(n uint16) int64

+ func Int64FromUint32(n uint32) int64

+ func Int64FromUint64(n uint64) int64

+ func Int64FromUint8(n uint8) int64

+ func Int64FromUintptr(n uintptr) int64

+ func Int8(n int8) int8

+ func Int8FromComplex128(n complex128) int8

+ func Int8FromComplex64(n complex64) int8

+ func Int8FromFloat32(n float32) int8

+ func Int8FromFloat64(n float64) int8

+ func Int8FromInt16(n int16) int8

+ func Int8FromInt32(n int32) int8

+ func Int8FromInt64(n int64) int8

+ func Int8FromInt8(n int8) int8

+ func Int8FromUint16(n uint16) int8

+ func Int8FromUint32(n uint32) int8

+ func Int8FromUint64(n uint64) int8

+ func Int8FromUint8(n uint8) int8

+ func Int8FromUintptr(n uintptr) int8

+ func MemAuditReport() error

+ func MemAuditStart()

+ func NegInt16(n int16) int16

+ func NegInt32(n int32) int32

+ func NegInt64(n int64) int64

+ func NegInt8(n int8) int8

+ func NegUint16(n uint16) uint16

+ func NegUint32(n uint32) uint32

+ func NegUint64(n uint64) uint64

+ func NegUint8(n uint8) uint8

+ func NegUintptr(n uintptr) uintptr

+ func NewVaList(args ...interface{}) (va_list uintptr)

+ func NewVaListN(n int) (va_list uintptr)

+ func PostDecAtomicInt32(p *int32, d int32) int32

+ func PostDecAtomicInt64(p *int64, d int64) int64

+ func PostDecAtomicUint32(p *uint32, d uint32) uint32

+ func PostDecAtomicUint64(p *uint64, d uint64) uint64

+ func PostDecAtomicUintptr(p *uintptr, d uintptr) uintptr

+ func PostDecBitFieldPtr16Int16(p uintptr, d int16, w, off int, mask uint16) (r int16)

+ func PostDecBitFieldPtr16Int32(p uintptr, d int32, w, off int, mask uint16) (r int32)

+ func PostDecBitFieldPtr16Int64(p uintptr, d int64, w, off int, mask uint16) (r int64)

+ func PostDecBitFieldPtr16Int8(p uintptr, d int8, w, off int, mask uint16) (r int8)

+ func PostDecBitFieldPtr16Uint16(p uintptr, d uint16, w, off int, mask uint16) (r uint16)

+ func PostDecBitFieldPtr16Uint32(p uintptr, d uint32, w, off int, mask uint16) (r uint32)

+ func PostDecBitFieldPtr16Uint64(p uintptr, d uint64, w, off int, mask uint16) (r uint64)

+ func PostDecBitFieldPtr16Uint8(p uintptr, d uint8, w, off int, mask uint16) (r uint8)

+ func PostDecBitFieldPtr32Int16(p uintptr, d int16, w, off int, mask uint32) (r int16)

+ func PostDecBitFieldPtr32Int32(p uintptr, d int32, w, off int, mask uint32) (r int32)

+ func PostDecBitFieldPtr32Int64(p uintptr, d int64, w, off int, mask uint32) (r int64)

+ func PostDecBitFieldPtr32Int8(p uintptr, d int8, w, off int, mask uint32) (r int8)

+ func PostDecBitFieldPtr32Uint16(p uintptr, d uint16, w, off int, mask uint32) (r uint16)

+ func PostDecBitFieldPtr32Uint32(p uintptr, d uint32, w, off int, mask uint32) (r uint32)

+ func PostDecBitFieldPtr32Uint64(p uintptr, d uint64, w, off int, mask uint32) (r uint64)

+ func PostDecBitFieldPtr32Uint8(p uintptr, d uint8, w, off int, mask uint32) (r uint8)

+ func PostDecBitFieldPtr64Int16(p uintptr, d int16, w, off int, mask uint64) (r int16)

+ func PostDecBitFieldPtr64Int32(p uintptr, d int32, w, off int, mask uint64) (r int32)

+ func PostDecBitFieldPtr64Int64(p uintptr, d int64, w, off int, mask uint64) (r int64)

+ func PostDecBitFieldPtr64Int8(p uintptr, d int8, w, off int, mask uint64) (r int8)

+ func PostDecBitFieldPtr64Uint16(p uintptr, d uint16, w, off int, mask uint64) (r uint16)

+ func PostDecBitFieldPtr64Uint32(p uintptr, d uint32, w, off int, mask uint64) (r uint32)

+ func PostDecBitFieldPtr64Uint64(p uintptr, d uint64, w, off int, mask uint64) (r uint64)

+ func PostDecBitFieldPtr64Uint8(p uintptr, d uint8, w, off int, mask uint64) (r uint8)

+ func PostDecBitFieldPtr8Int16(p uintptr, d int16, w, off int, mask uint8) (r int16)

+ func PostDecBitFieldPtr8Int32(p uintptr, d int32, w, off int, mask uint8) (r int32)

+ func PostDecBitFieldPtr8Int64(p uintptr, d int64, w, off int, mask uint8) (r int64)

+ func PostDecBitFieldPtr8Int8(p uintptr, d int8, w, off int, mask uint8) (r int8)

+ func PostDecBitFieldPtr8Uint16(p uintptr, d uint16, w, off int, mask uint8) (r uint16)

+ func PostDecBitFieldPtr8Uint32(p uintptr, d uint32, w, off int, mask uint8) (r uint32)

+ func PostDecBitFieldPtr8Uint64(p uintptr, d uint64, w, off int, mask uint8) (r uint64)

+ func PostDecBitFieldPtr8Uint8(p uintptr, d uint8, w, off int, mask uint8) (r uint8)

+ func PostDecComplex128(p *complex128, d complex128) complex128

+ func PostDecComplex64(p *complex64, d complex64) complex64

+ func PostDecFloat32(p *float32, d float32) float32

+ func PostDecFloat64(p *float64, d float64) float64

+ func PostDecInt16(p *int16, d int16) int16

+ func PostDecInt32(p *int32, d int32) int32

+ func PostDecInt64(p *int64, d int64) int64

+ func PostDecInt8(p *int8, d int8) int8

+ func PostDecUint16(p *uint16, d uint16) uint16

+ func PostDecUint32(p *uint32, d uint32) uint32

+ func PostDecUint64(p *uint64, d uint64) uint64

+ func PostDecUint8(p *uint8, d uint8) uint8

+ func PostDecUintptr(p *uintptr, d uintptr) uintptr

+ func PostIncAtomicInt32(p *int32, d int32) int32

+ func PostIncAtomicInt64(p *int64, d int64) int64

+ func PostIncAtomicUint32(p *uint32, d uint32) uint32

+ func PostIncAtomicUint64(p *uint64, d uint64) uint64

+ func PostIncAtomicUintptr(p *uintptr, d uintptr) uintptr

+ func PostIncBitFieldPtr16Int16(p uintptr, d int16, w, off int, mask uint16) (r int16)

+ func PostIncBitFieldPtr16Int32(p uintptr, d int32, w, off int, mask uint16) (r int32)

+ func PostIncBitFieldPtr16Int64(p uintptr, d int64, w, off int, mask uint16) (r int64)

+ func PostIncBitFieldPtr16Int8(p uintptr, d int8, w, off int, mask uint16) (r int8)

+ func PostIncBitFieldPtr16Uint16(p uintptr, d uint16, w, off int, mask uint16) (r uint16)

+ func PostIncBitFieldPtr16Uint32(p uintptr, d uint32, w, off int, mask uint16) (r uint32)

+ func PostIncBitFieldPtr16Uint64(p uintptr, d uint64, w, off int, mask uint16) (r uint64)

+ func PostIncBitFieldPtr16Uint8(p uintptr, d uint8, w, off int, mask uint16) (r uint8)

+ func PostIncBitFieldPtr32Int16(p uintptr, d int16, w, off int, mask uint32) (r int16)

+ func PostIncBitFieldPtr32Int32(p uintptr, d int32, w, off int, mask uint32) (r int32)

+ func PostIncBitFieldPtr32Int64(p uintptr, d int64, w, off int, mask uint32) (r int64)

+ func PostIncBitFieldPtr32Int8(p uintptr, d int8, w, off int, mask uint32) (r int8)

+ func PostIncBitFieldPtr32Uint16(p uintptr, d uint16, w, off int, mask uint32) (r uint16)

+ func PostIncBitFieldPtr32Uint32(p uintptr, d uint32, w, off int, mask uint32) (r uint32)

+ func PostIncBitFieldPtr32Uint64(p uintptr, d uint64, w, off int, mask uint32) (r uint64)

+ func PostIncBitFieldPtr32Uint8(p uintptr, d uint8, w, off int, mask uint32) (r uint8)

+ func PostIncBitFieldPtr64Int16(p uintptr, d int16, w, off int, mask uint64) (r int16)

+ func PostIncBitFieldPtr64Int32(p uintptr, d int32, w, off int, mask uint64) (r int32)

+ func PostIncBitFieldPtr64Int64(p uintptr, d int64, w, off int, mask uint64) (r int64)

+ func PostIncBitFieldPtr64Int8(p uintptr, d int8, w, off int, mask uint64) (r int8)

+ func PostIncBitFieldPtr64Uint16(p uintptr, d uint16, w, off int, mask uint64) (r uint16)

+ func PostIncBitFieldPtr64Uint32(p uintptr, d uint32, w, off int, mask uint64) (r uint32)

+ func PostIncBitFieldPtr64Uint64(p uintptr, d uint64, w, off int, mask uint64) (r uint64)

+ func PostIncBitFieldPtr64Uint8(p uintptr, d uint8, w, off int, mask uint64) (r uint8)

+ func PostIncBitFieldPtr8Int16(p uintptr, d int16, w, off int, mask uint8) (r int16)

+ func PostIncBitFieldPtr8Int32(p uintptr, d int32, w, off int, mask uint8) (r int32)

+ func PostIncBitFieldPtr8Int64(p uintptr, d int64, w, off int, mask uint8) (r int64)

+ func PostIncBitFieldPtr8Int8(p uintptr, d int8, w, off int, mask uint8) (r int8)

+ func PostIncBitFieldPtr8Uint16(p uintptr, d uint16, w, off int, mask uint8) (r uint16)

+ func PostIncBitFieldPtr8Uint32(p uintptr, d uint32, w, off int, mask uint8) (r uint32)

+ func PostIncBitFieldPtr8Uint64(p uintptr, d uint64, w, off int, mask uint8) (r uint64)

+ func PostIncBitFieldPtr8Uint8(p uintptr, d uint8, w, off int, mask uint8) (r uint8)

+ func PostIncComplex128(p *complex128, d complex128) complex128

+ func PostIncComplex64(p *complex64, d complex64) complex64

+ func PostIncFloat32(p *float32, d float32) float32

+ func PostIncFloat64(p *float64, d float64) float64

+ func PostIncInt16(p *int16, d int16) int16

+ func PostIncInt32(p *int32, d int32) int32

+ func PostIncInt64(p *int64, d int64) int64

+ func PostIncInt8(p *int8, d int8) int8

+ func PostIncUint16(p *uint16, d uint16) uint16

+ func PostIncUint32(p *uint32, d uint32) uint32

+ func PostIncUint64(p *uint64, d uint64) uint64

+ func PostIncUint8(p *uint8, d uint8) uint8

+ func PostIncUintptr(p *uintptr, d uintptr) uintptr

+ func PreDecAtomicInt32(p *int32, d int32) int32

+ func PreDecAtomicInt64(p *int64, d int64) int64

+ func PreDecAtomicUint32(p *uint32, d uint32) uint32

+ func PreDecAtomicUint64(p *uint64, d uint64) uint64

+ func PreDecAtomicUintptr(p *uintptr, d uintptr) uintptr

+ func PreDecComplex128(p *complex128, d complex128) complex128

+ func PreDecComplex64(p *complex64, d complex64) complex64

+ func PreDecFloat32(p *float32, d float32) float32

+ func PreDecFloat64(p *float64, d float64) float64

+ func PreDecInt16(p *int16, d int16) int16

+ func PreDecInt32(p *int32, d int32) int32

+ func PreDecInt64(p *int64, d int64) int64

+ func PreDecInt8(p *int8, d int8) int8

+ func PreDecUint16(p *uint16, d uint16) uint16

+ func PreDecUint32(p *uint32, d uint32) uint32

+ func PreDecUint64(p *uint64, d uint64) uint64

+ func PreDecUint8(p *uint8, d uint8) uint8

+ func PreDecUintptr(p *uintptr, d uintptr) uintptr

+ func PreIncAtomicInt32(p *int32, d int32) int32

+ func PreIncAtomicInt64(p *int64, d int64) int64

+ func PreIncAtomicUint32(p *uint32, d uint32) uint32

+ func PreIncAtomicUint64(p *uint64, d uint64) uint64

+ func PreIncAtomicUintptr(p *uintptr, d uintptr) uintptr

+ func PreIncComplex128(p *complex128, d complex128) complex128

+ func PreIncComplex64(p *complex64, d complex64) complex64

+ func PreIncFloat32(p *float32, d float32) float32

+ func PreIncFloat64(p *float64, d float64) float64

+ func PreIncInt16(p *int16, d int16) int16

+ func PreIncInt32(p *int32, d int32) int32

+ func PreIncInt64(p *int64, d int64) int64

+ func PreIncInt8(p *int8, d int8) int8

+ func PreIncUint16(p *uint16, d uint16) uint16

+ func PreIncUint32(p *uint32, d uint32) uint32

+ func PreIncUint64(p *uint64, d uint64) uint64

+ func PreIncUint8(p *uint8, d uint8) uint8

+ func PreIncUintptr(p *uintptr, d uintptr) uintptr

+ func SetBitFieldPtr16Int16(p uintptr, v int16, off int, mask uint16)

+ func SetBitFieldPtr16Int32(p uintptr, v int32, off int, mask uint16)

+ func SetBitFieldPtr16Int64(p uintptr, v int64, off int, mask uint16)

+ func SetBitFieldPtr16Int8(p uintptr, v int8, off int, mask uint16)

+ func SetBitFieldPtr16Uint16(p uintptr, v uint16, off int, mask uint16)

+ func SetBitFieldPtr16Uint32(p uintptr, v uint32, off int, mask uint16)

+ func SetBitFieldPtr16Uint64(p uintptr, v uint64, off int, mask uint16)

+ func SetBitFieldPtr16Uint8(p uintptr, v uint8, off int, mask uint16)

+ func SetBitFieldPtr32Int16(p uintptr, v int16, off int, mask uint32)

+ func SetBitFieldPtr32Int32(p uintptr, v int32, off int, mask uint32)

+ func SetBitFieldPtr32Int64(p uintptr, v int64, off int, mask uint32)

+ func SetBitFieldPtr32Int8(p uintptr, v int8, off int, mask uint32)

+ func SetBitFieldPtr32Uint16(p uintptr, v uint16, off int, mask uint32)

+ func SetBitFieldPtr32Uint32(p uintptr, v uint32, off int, mask uint32)

+ func SetBitFieldPtr32Uint64(p uintptr, v uint64, off int, mask uint32)

+ func SetBitFieldPtr32Uint8(p uintptr, v uint8, off int, mask uint32)

+ func SetBitFieldPtr64Int16(p uintptr, v int16, off int, mask uint64)

+ func SetBitFieldPtr64Int32(p uintptr, v int32, off int, mask uint64)

+ func SetBitFieldPtr64Int64(p uintptr, v int64, off int, mask uint64)

+ func SetBitFieldPtr64Int8(p uintptr, v int8, off int, mask uint64)

+ func SetBitFieldPtr64Uint16(p uintptr, v uint16, off int, mask uint64)

+ func SetBitFieldPtr64Uint32(p uintptr, v uint32, off int, mask uint64)

+ func SetBitFieldPtr64Uint64(p uintptr, v uint64, off int, mask uint64)

+ func SetBitFieldPtr64Uint8(p uintptr, v uint8, off int, mask uint64)

+ func SetBitFieldPtr8Int16(p uintptr, v int16, off int, mask uint8)

+ func SetBitFieldPtr8Int32(p uintptr, v int32, off int, mask uint8)

+ func SetBitFieldPtr8Int64(p uintptr, v int64, off int, mask uint8)

+ func SetBitFieldPtr8Int8(p uintptr, v int8, off int, mask uint8)

+ func SetBitFieldPtr8Uint16(p uintptr, v uint16, off int, mask uint8)

+ func SetBitFieldPtr8Uint32(p uintptr, v uint32, off int, mask uint8)

+ func SetBitFieldPtr8Uint64(p uintptr, v uint64, off int, mask uint8)

+ func SetBitFieldPtr8Uint8(p uintptr, v uint8, off int, mask uint8)

+ func SetEnviron(t *TLS, env []string)

+ func Start(main func(*TLS, int32, uintptr) int32)

+ func ThreadProc(p uintptr) uintptr — windows/amd64

+ func Uint16(n uint16) uint16

+ func Uint16FromComplex128(n complex128) uint16

+ func Uint16FromComplex64(n complex64) uint16

+ func Uint16FromFloat32(n float32) uint16

+ func Uint16FromFloat64(n float64) uint16

+ func Uint16FromInt16(n int16) uint16

+ func Uint16FromInt32(n int32) uint16

+ func Uint16FromInt64(n int64) uint16

+ func Uint16FromInt8(n int8) uint16

+ func Uint16FromUint16(n uint16) uint16

+ func Uint16FromUint32(n uint32) uint16

+ func Uint16FromUint64(n uint64) uint16

+ func Uint16FromUint8(n uint8) uint16

+ func Uint16FromUintptr(n uintptr) uint16

+ func Uint32(n uint32) uint32

+ func Uint32FromComplex128(n complex128) uint32

+ func Uint32FromComplex64(n complex64) uint32

+ func Uint32FromFloat32(n float32) uint32

+ func Uint32FromFloat64(n float64) uint32

+ func Uint32FromInt16(n int16) uint32

+ func Uint32FromInt32(n int32) uint32

+ func Uint32FromInt64(n int64) uint32

+ func Uint32FromInt8(n int8) uint32

+ func Uint32FromUint16(n uint16) uint32

+ func Uint32FromUint32(n uint32) uint32

+ func Uint32FromUint64(n uint64) uint32

+ func Uint32FromUint8(n uint8) uint32

+ func Uint32FromUintptr(n uintptr) uint32

+ func Uint64(n uint64) uint64

+ func Uint64FromComplex128(n complex128) uint64

+ func Uint64FromComplex64(n complex64) uint64

+ func Uint64FromFloat32(n float32) uint64

+ func Uint64FromFloat64(n float64) uint64

+ func Uint64FromInt16(n int16) uint64

+ func Uint64FromInt32(n int32) uint64

+ func Uint64FromInt64(n int64) uint64

+ func Uint64FromInt8(n int8) uint64

+ func Uint64FromUint16(n uint16) uint64

+ func Uint64FromUint32(n uint32) uint64

+ func Uint64FromUint64(n uint64) uint64

+ func Uint64FromUint8(n uint8) uint64

+ func Uint64FromUintptr(n uintptr) uint64

+ func Uint8(n uint8) uint8

+ func Uint8FromComplex128(n complex128) uint8

+ func Uint8FromComplex64(n complex64) uint8

+ func Uint8FromFloat32(n float32) uint8

+ func Uint8FromFloat64(n float64) uint8

+ func Uint8FromInt16(n int16) uint8

+ func Uint8FromInt32(n int32) uint8

+ func Uint8FromInt64(n int64) uint8

+ func Uint8FromInt8(n int8) uint8

+ func Uint8FromUint16(n uint16) uint8

+ func Uint8FromUint32(n uint32) uint8

+ func Uint8FromUint64(n uint64) uint8

+ func Uint8FromUint8(n uint8) uint8

+ func Uint8FromUintptr(n uintptr) uint8

+ func Uintptr(n uintptr) uintptr

+ func UintptrFromComplex128(n complex128) uintptr

+ func UintptrFromComplex64(n complex64) uintptr

+ func UintptrFromFloat32(n float32) uintptr

+ func UintptrFromFloat64(n float64) uintptr

+ func UintptrFromInt16(n int16) uintptr

+ func UintptrFromInt32(n int32) uintptr

+ func UintptrFromInt64(n int64) uintptr

+ func UintptrFromInt8(n int8) uintptr

+ func UintptrFromUint16(n uint16) uintptr

+ func UintptrFromUint32(n uint32) uintptr

+ func UintptrFromUint64(n uint64) uintptr

+ func UintptrFromUint8(n uint8) uintptr

+ func UintptrFromUintptr(n uintptr) uintptr

+ func UsableSize(p uintptr) types.Size_t

+ func VaFloat32(app *uintptr) float32

+ func VaFloat64(app *uintptr) float64

+ func VaInt32(app *uintptr) int32

+ func VaInt64(app *uintptr) int64

+ func VaList(p uintptr, args ...interface{}) (r uintptr)

+ func VaUint32(app *uintptr) uint32

+ func VaUint64(app *uintptr) uint64

+ func VaUintptr(app *uintptr) uintptr

+ func Watch()

+ func WatchDelete(p uintptr)

+ func WatchFloat32(p uintptr, msg string)

+ func WatchFloat64(p uintptr, msg string)

+ func WatchInt16(p uintptr, msg string)

+ func WatchInt32(p uintptr, msg string)

+ func WatchInt64(p uintptr, msg string)

+ func WatchInt8(p uintptr, msg string)

+ func WatchPtr(p uintptr, msg string)

+ func WatchUint16(p uintptr, msg string)

+ func WatchUint32(p uintptr, msg string)

+ func WatchUint64(p uintptr, msg string)

+ func WatchUint8(p uintptr, msg string)

+ func WindowsAttrbiutesToStat(fa uint32) uint16 — windows/amd64

+ func WindowsTickToUnixSeconds(windowsTicks int64) int64 — windows/amd64

+ func XAccessCheck(t *TLS, pSecurityDescriptor, ClientToken uintptr, DesiredAccess uint32, ...) int32 — windows/amd64

+ func XAddAccessDeniedAce(t *TLS, pAcl uintptr, dwAceRevision, AccessMask uint32, pSid uintptr) int32 — windows/amd64

+ func XAddAce(t *TLS, pAcl uintptr, dwAceRevision, dwStartingAceIndex uint32, ...) int32 — windows/amd64

+ func XAreFileApisANSI(t *TLS) int32 — windows/amd64

+ func XBuildCommDCBW(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XCancelSynchronousIo(t *TLS, hThread uintptr) int32 — windows/amd64

+ func XCharLowerW(t *TLS, lpsz uintptr) uintptr — windows/amd64

+ func XClearCommError(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XCloseHandle(t *TLS, hObject uintptr) int32 — windows/amd64

+ func XCopyFileW(t *TLS, lpExistingFileName, lpNewFileName uintptr, bFailIfExists int32) int32 — windows/amd64

+ func XCreateDirectoryW(t *TLS, lpPathName, lpSecurityAttributes uintptr) int32 — windows/amd64

+ func XCreateEventA(t *TLS, lpEventAttributes uintptr, bManualReset, bInitialState int32, ...) uintptr — windows/amd64

+ func XCreateEventW(t *TLS, lpEventAttributes uintptr, bManualReset, bInitialState int32, ...) uintptr — windows/amd64

+ func XCreateFileA(t *TLS, lpFileName uintptr, dwDesiredAccess, dwShareMode uint32, ...) uintptr — windows/amd64

+ func XCreateFileMappingA(t *TLS, hFile, lpFileMappingAttributes uintptr, ...) uintptr — windows/amd64

+ func XCreateFileMappingW(t *TLS, hFile, lpFileMappingAttributes uintptr, ...) uintptr — windows/amd64

+ func XCreateFileW(t *TLS, lpFileName uintptr, dwDesiredAccess, dwShareMode uint32, ...) uintptr — windows/amd64

+ func XCreateHardLinkW(t *TLS, lpFileName, lpExistingFileName, lpSecurityAttributes uintptr) int32 — windows/amd64

+ func XCreateMutexW(t *TLS, lpMutexAttributes uintptr, bInitialOwner int32, lpName uintptr) uintptr — windows/amd64

+ func XCreatePipe(t *TLS, hReadPipe, hWritePipe, lpPipeAttributes uintptr, nSize uint32) int32 — windows/amd64

+ func XCreateProcessA(t *TLS, ...) int32 — windows/amd64

+ func XCreateProcessW(t *TLS, ...) int32 — windows/amd64

+ func XCreateThread(t *TLS, lpThreadAttributes uintptr, dwStackSize types.Size_t, ...) uintptr — windows/amd64

+ func XCreateWindowExW(t *TLS, dwExStyle uint32, lpClassName, lpWindowName uintptr, dwStyle uint32, ...) uintptr — windows/amd64

+ func XDdeAbandonTransaction(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XDdeAccessData(t *TLS, _ ...interface{}) uintptr — windows/amd64

+ func XDdeClientTransaction(t *TLS, pData uintptr, cbData uint32, hConv uintptr, hszItem uintptr, ...) uintptr — windows/amd64

+ func XDdeConnect(t *TLS, _ ...interface{}) uintptr — windows/amd64

+ func XDdeCreateDataHandle(t *TLS, _ ...interface{}) uintptr — windows/amd64

+ func XDdeCreateStringHandleW(t *TLS, _ ...interface{}) uintptr — windows/amd64

+ func XDdeDisconnect(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XDdeFreeDataHandle(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XDdeFreeStringHandle(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XDdeGetData(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XDdeGetLastError(t *TLS, _ ...interface{}) uint32 — windows/amd64

+ func XDdeInitializeW(t *TLS, _ ...interface{}) uint32 — windows/amd64

+ func XDdeNameService(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XDdeQueryStringW(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XDdeUnaccessData(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XDdeUninitialize(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XDebugBreak(t *TLS) — windows/amd64

+ func XDefWindowProcW(t *TLS, _ ...interface{}) int64 — windows/amd64

+ func XDeleteCriticalSection(t *TLS, lpCriticalSection uintptr) — windows/amd64

+ func XDeleteFileA(t *TLS, lpFileName uintptr) int32 — windows/amd64

+ func XDeleteFileW(t *TLS, lpFileName uintptr) int32 — windows/amd64

+ func XDestroyWindow(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XDeviceIoControl(t *TLS, hDevice uintptr, dwIoControlCode uint32, lpInBuffer uintptr, ...) int32 — windows/amd64

+ func XDispatchMessageW(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XDuplicateHandle(t *TLS, ...) int32 — windows/amd64

+ func XEnterCriticalSection(t *TLS, lpCriticalSection uintptr) — windows/amd64

+ func XEnumWindows(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XEqualSid(t *TLS, pSid1, pSid2 uintptr) int32 — windows/amd64

+ func XEscapeCommFunction(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XExitProcess(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XFindClose(t *TLS, hFindFile uintptr) int32 — windows/amd64

+ func XFindFirstFileExW(t *TLS, lpFileName uintptr, fInfoLevelId int32, lpFindFileData uintptr, ...) uintptr — windows/amd64

+ func XFindFirstFileW(t *TLS, lpFileName, lpFindFileData uintptr) uintptr — windows/amd64

+ func XFindNextFileW(t *TLS, hFindFile, lpFindFileData uintptr) int32 — windows/amd64

+ func XFlushFileBuffers(t *TLS, hFile uintptr) int32 — windows/amd64

+ func XFlushViewOfFile(t *TLS, lpBaseAddress uintptr, dwNumberOfBytesToFlush types.Size_t) int32 — windows/amd64

+ func XFormatMessageA(t *TLS, dwFlagsAndAttributes uint32, lpSource uintptr, ...) uint32 — windows/amd64

+ func XFormatMessageW(t *TLS, dwFlags uint32, lpSource uintptr, dwMessageId, dwLanguageId uint32, ...) uint32 — windows/amd64

+ func XFreeLibrary(t *TLS, hLibModule uintptr) int32 — windows/amd64

+ func XGetACP(t *TLS) uint32 — windows/amd64

+ func XGetAce(t *TLS, pAcl uintptr, dwAceIndex uint32, pAce uintptr) int32 — windows/amd64

+ func XGetAclInformation(t *TLS, pAcl, pAclInformation uintptr, ...) int32 — windows/amd64

+ func XGetCommModemStatus(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XGetCommState(t *TLS, hFile, lpDCB uintptr) int32 — windows/amd64

+ func XGetCommandLineW(t *TLS) uintptr — windows/amd64

+ func XGetComputerNameExW(t *TLS, nameType int32, lpBuffer, nSize uintptr) int32 — windows/amd64

+ func XGetComputerNameW(t *TLS, lpBuffer, nSize uintptr) int32 — windows/amd64

+ func XGetConsoleCP(t *TLS) uint32 — windows/amd64

+ func XGetConsoleMode(t *TLS, hConsoleHandle, lpMode uintptr) int32 — windows/amd64

+ func XGetConsoleScreenBufferInfo(t *TLS, hConsoleOutput, lpConsoleScreenBufferInfo uintptr) int32 — windows/amd64

+ func XGetCurrentDirectoryW(t *TLS, nBufferLength uint32, lpBuffer uintptr) uint32 — windows/amd64

+ func XGetCurrentProcess(t *TLS) uintptr — windows/amd64

+ func XGetCurrentProcessId(t *TLS) uint32 — windows/amd64

+ func XGetCurrentThread(t *TLS) uintptr — windows/amd64

+ func XGetCurrentThreadId(t *TLS) uint32 — windows/amd64

+ func XGetDiskFreeSpaceA(t *TLS, ...) int32 — windows/amd64

+ func XGetDiskFreeSpaceW(t *TLS, ...) int32 — windows/amd64

+ func XGetEnvironmentVariableA(t *TLS, lpName, lpBuffer uintptr, nSize uint32) uint32 — windows/amd64

+ func XGetEnvironmentVariableW(t *TLS, lpName, lpBuffer uintptr, nSize uint32) uint32 — windows/amd64

+ func XGetExitCodeProcess(t *TLS, hProcess, lpExitCode uintptr) int32 — windows/amd64

+ func XGetExitCodeThread(t *TLS, hThread, lpExitCode uintptr) int32 — windows/amd64

+ func XGetFileAttributesA(t *TLS, lpFileName uintptr) uint32 — windows/amd64

+ func XGetFileAttributesExW(t *TLS, lpFileName uintptr, fInfoLevelId uint32, lpFileInformation uintptr) int32 — windows/amd64

+ func XGetFileAttributesW(t *TLS, lpFileName uintptr) uint32 — windows/amd64

+ func XGetFileInformationByHandle(t *TLS, hFile, lpFileInformation uintptr) int32 — windows/amd64

+ func XGetFileSecurityA(t *TLS, lpFileName uintptr, RequestedInformation uint32, ...) int32 — windows/amd64

+ func XGetFileSecurityW(t *TLS, lpFileName uintptr, RequestedInformation uint32, ...) int32 — windows/amd64

+ func XGetFileSize(t *TLS, hFile, lpFileSizeHigh uintptr) uint32 — windows/amd64

+ func XGetFileType(t *TLS, hFile uintptr) uint32 — windows/amd64

+ func XGetFullPathNameA(t *TLS, lpFileName uintptr, nBufferLength uint32, lpBuffer, lpFilePart uintptr) uint32 — windows/amd64

+ func XGetFullPathNameW(t *TLS, lpFileName uintptr, nBufferLength uint32, lpBuffer, lpFilePart uintptr) uint32 — windows/amd64

+ func XGetLastError(t *TLS) uint32 — windows/amd64

+ func XGetLengthSid(t *TLS, pSid uintptr) uint32 — windows/amd64

+ func XGetLogicalDriveStringsA(t *TLS, nBufferLength uint32, lpBuffer uintptr) uint32 — windows/amd64

+ func XGetMessageW(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XGetModuleFileNameA(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XGetModuleFileNameW(t *TLS, hModule, lpFileName uintptr, nSize uint32) uint32 — windows/amd64

+ func XGetModuleHandleA(t *TLS, lpModuleName uintptr) uintptr — windows/amd64

+ func XGetModuleHandleW(t *TLS, lpModuleName uintptr) uintptr — windows/amd64

+ func XGetNamedSecurityInfoW(t *TLS, pObjectName uintptr, ObjectType, SecurityInfo uint32, ...) uint32 — windows/amd64

+ func XGetOverlappedResult(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XGetPrivateProfileStringA(t *TLS, lpAppName, lpKeyName, lpDefault, lpReturnedString uintptr, ...) uint32 — windows/amd64

+ func XGetProcAddress(t *TLS, hModule, lpProcName uintptr) uintptr — windows/amd64

+ func XGetProcessHeap(t *TLS) uintptr — windows/amd64

+ func XGetProfilesDirectoryW(t *TLS, lpProfileDir, lpcchSize uintptr) int32 — windows/amd64

+ func XGetSecurityDescriptorDacl(t *TLS, pSecurityDescriptor, lpbDaclPresent, pDacl, lpbDaclDefaulted uintptr) int32 — windows/amd64

+ func XGetSecurityDescriptorOwner(t *TLS, pSecurityDescriptor, pOwner, lpbOwnerDefaulted uintptr) int32 — windows/amd64

+ func XGetShortPathNameW(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XGetSidIdentifierAuthority(t *TLS, pSid uintptr) uintptr — windows/amd64

+ func XGetSidLengthRequired(t *TLS, nSubAuthorityCount uint8) int32 — windows/amd64

+ func XGetSidSubAuthority(t *TLS, pSid uintptr, nSubAuthority uint32) uintptr — windows/amd64

+ func XGetStdHandle(t *TLS, nStdHandle uint32) uintptr — windows/amd64

+ func XGetSystemInfo(t *TLS, lpSystemInfo uintptr) — windows/amd64

+ func XGetSystemTime(t *TLS, lpSystemTime uintptr) — windows/amd64

+ func XGetSystemTimeAsFileTime(t *TLS, lpSystemTimeAsFileTime uintptr) — windows/amd64

+ func XGetTempFileNameW(t *TLS, lpPathName, lpPrefixString uintptr, uUnique uint32, ...) uint32 — windows/amd64

+ func XGetTempPathA(t *TLS, nBufferLength uint32, lpBuffer uintptr) uint32 — windows/amd64

+ func XGetTempPathW(t *TLS, nBufferLength uint32, lpBuffer uintptr) uint32 — windows/amd64

+ func XGetTickCount(t *TLS) uint32 — windows/amd64

+ func XGetTokenInformation(t *TLS, TokenHandle uintptr, TokenInformationClass uint32, ...) int32 — windows/amd64

+ func XGetUserNameW(t *TLS, lpBuffer, pcbBuffer uintptr) int32 — windows/amd64

+ func XGetVersionExA(t *TLS, lpVersionInformation uintptr) int32 — windows/amd64

+ func XGetVersionExW(t *TLS, lpVersionInformation uintptr) int32 — windows/amd64

+ func XGetVolumeInformationA(t *TLS, lpRootPathName, lpVolumeNameBuffer uintptr, nVolumeNameSize uint32, ...) int32 — windows/amd64

+ func XGetVolumeInformationW(t *TLS, lpRootPathName, lpVolumeNameBuffer uintptr, nVolumeNameSize uint32, ...) int32 — windows/amd64

+ func XGetVolumeNameForVolumeMountPointW(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XGetWindowLongPtrW(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XGetWindowsDirectoryA(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XGlobalAddAtomW(t *TLS, _ ...interface{}) uint16 — windows/amd64

+ func XGlobalDeleteAtom(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XGlobalGetAtomNameW(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XHeapAlloc(t *TLS, hHeap uintptr, dwFlags uint32, dwBytes types.Size_t) uintptr — windows/amd64

+ func XHeapCompact(t *TLS, hHeap uintptr, dwFlags uint32) types.Size_t — windows/amd64

+ func XHeapCreate(t *TLS, flOptions uint32, dwInitialSize, dwMaximumSize types.Size_t) uintptr — windows/amd64

+ func XHeapDestroy(t *TLS, hHeap uintptr) int32 — windows/amd64

+ func XHeapFree(t *TLS, hHeap uintptr, dwFlags uint32, lpMem uintptr) int32 — windows/amd64

+ func XHeapReAlloc(t *TLS, hHeap uintptr, dwFlags uint32, lpMem uintptr, dwBytes types.Size_t) uintptr — windows/amd64

+ func XHeapSize(t *TLS, hHeap uintptr, dwFlags uint32, lpMem uintptr) types.Size_t — windows/amd64

+ func XHeapValidate(t *TLS, hHeap uintptr, dwFlags uint32, lpMem uintptr) int32 — windows/amd64

+ func XIN6_ADDR_EQUAL(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XIN6_IS_ADDR_V4MAPPED(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XImpersonateSelf(t *TLS, ImpersonationLevel int32) int32 — windows/amd64

+ func XInitializeAcl(t *TLS, pAcl uintptr, nAclLength, dwAclRevision uint32) int32 — windows/amd64

+ func XInitializeCriticalSection(t *TLS, lpCriticalSection uintptr) — windows/amd64

+ func XInitializeSid(t *TLS, Sid, pIdentifierAuthority uintptr, nSubAuthorityCount uint8) int32 — windows/amd64

+ func XIsDebuggerPresent(t *TLS) int32 — windows/amd64

+ func XIsWindow(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XKillTimer(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XLeaveCriticalSection(t *TLS, lpCriticalSection uintptr) — windows/amd64

+ func XLoadLibraryA(t *TLS, lpLibFileName uintptr) uintptr — windows/amd64

+ func XLoadLibraryExW(t *TLS, lpLibFileName, hFile uintptr, dwFlags uint32) uintptr — windows/amd64

+ func XLoadLibraryW(t *TLS, lpLibFileName uintptr) uintptr — windows/amd64

+ func XLocalFree(t *TLS, hMem uintptr) uintptr — windows/amd64

+ func XLockFile(t *TLS, hFile uintptr, ...) int32 — windows/amd64

+ func XLockFileEx(t *TLS, hFile uintptr, ...) int32 — windows/amd64

+ func XMapViewOfFile(t *TLS, hFileMappingObject uintptr, ...) uintptr — windows/amd64

+ func XMessageBeep(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XMessageBoxW(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XMoveFileW(t *TLS, lpExistingFileName, lpNewFileName uintptr) int32 — windows/amd64

+ func XMsgWaitForMultipleObjectsEx(t *TLS, nCount uint32, pHandles uintptr, ...) uint32 — windows/amd64

+ func XMultiByteToWideChar(t *TLS, CodePage uint32, dwFlags uint32, lpMultiByteStr uintptr, ...) int32 — windows/amd64

+ func XNetApiBufferFree(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XNetGetDCName(t *TLS, ServerName, DomainName, Buffer uintptr) int32 — windows/amd64

+ func XNetUserGetInfo(t *TLS, servername, username uintptr, level uint32, bufptr uintptr) uint32 — windows/amd64

+ func XOpenEventA(t *TLS, dwDesiredAccess uint32, bInheritHandle uint32, lpName uintptr) uintptr — windows/amd64

+ func XOpenProcessToken(t *TLS, ProcessHandle uintptr, DesiredAccess uint32, TokenHandle uintptr) int32 — windows/amd64

+ func XOpenThreadToken(t *TLS, ThreadHandle uintptr, DesiredAccess uint32, OpenAsSelf int32, ...) int32 — windows/amd64

+ func XOutputDebugStringA(t *TLS, lpOutputString uintptr) — windows/amd64

+ func XOutputDebugStringW(t *TLS, lpOutputString uintptr) — windows/amd64

+ func XPeekConsoleInputW(t *TLS, hConsoleInput, lpBuffer uintptr, nLength uint32, ...) int32 — windows/amd64

+ func XPeekMessageW(t *TLS, lpMsg, hWnd uintptr, wMsgFilterMin, wMsgFilterMax, wRemoveMsg uint32) int32 — windows/amd64

+ func XPeekNamedPipe(t *TLS, hNamedPipe, lpBuffer uintptr, nBufferSize uint32, ...) int32 — windows/amd64

+ func XPostMessageW(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XPostQuitMessage(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XPurgeComm(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XQueryPerformanceCounter(t *TLS, lpPerformanceCount uintptr) int32 — windows/amd64

+ func XQueryPerformanceFrequency(t *TLS, lpFrequency uintptr) int32 — windows/amd64

+ func XRaiseException(t *TLS, dwExceptionCode, dwExceptionFlags, nNumberOfArguments uint32, ...) — windows/amd64

+ func XReadConsoleW(t *TLS, hConsoleInput, lpBuffer uintptr, nNumberOfCharsToRead uint32, ...) int32 — windows/amd64

+ func XReadFile(t *TLS, hFile, lpBuffer uintptr, nNumberOfBytesToRead uint32, ...) int32 — windows/amd64

+ func XRegCloseKey(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XRegConnectRegistryW(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XRegCreateKeyExW(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XRegDeleteKeyW(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XRegDeleteValueW(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XRegEnumKeyExW(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XRegEnumValueW(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XRegOpenKeyExW(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XRegQueryValueExW(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XRegSetValueExW(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XRegisterClassExW(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XRegisterClassW(t *TLS, lpWndClass uintptr) int32 — windows/amd64

+ func XRemoveDirectoryW(t *TLS, lpPathName uintptr) int32 — windows/amd64

+ func XResetEvent(t *TLS, hEvent uintptr) int32 — windows/amd64

+ func XRevertToSelf(t *TLS) int32 — windows/amd64

+ func XRtlGetVersion(t *TLS, lpVersionInformation uintptr) uintptr — windows/amd64

+ func XSearchPathW(t *TLS, lpPath, lpFileName, lpExtension uintptr, nBufferLength uint32, ...) int32 — windows/amd64

+ func XSendMessageTimeoutW(t *TLS, _ ...interface{}) int64 — windows/amd64

+ func XSendMessageW(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XSetCommState(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XSetCommTimeouts(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XSetConsoleCtrlHandler(t *TLS, HandlerRoutine uintptr, Add int32) int32 — windows/amd64

+ func XSetConsoleMode(t *TLS, hConsoleHandle uintptr, dwMode uint32) int32 — windows/amd64

+ func XSetConsoleTextAttribute(t *TLS, hConsoleOutput uintptr, wAttributes uint16) int32 — windows/amd64

+ func XSetCurrentDirectoryW(t *TLS, lpPathName uintptr) int32 — windows/amd64

+ func XSetEndOfFile(t *TLS, hFile uintptr) int32 — windows/amd64

+ func XSetErrorMode(t *TLS, uMode uint32) int32 — windows/amd64

+ func XSetEvent(t *TLS, hEvent uintptr) int32 — windows/amd64

+ func XSetFileAttributesW(t *TLS, lpFileName uintptr, dwFileAttributes uint32) int32 — windows/amd64

+ func XSetFilePointer(t *TLS, hFile uintptr, lDistanceToMove long, lpDistanceToMoveHigh uintptr, ...) uint32 — windows/amd64

+ func XSetFileTime(t *TLS, hFile uintptr, ...) int32 — windows/amd64

+ func XSetHandleInformation(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XSetNamedSecurityInfoA(t *TLS, pObjectName uintptr, ObjectType, SecurityInfo uint32, ...) uint32 — windows/amd64

+ func XSetThreadPriority(t *TLS, hThread uintptr, nPriority int32) int32 — windows/amd64

+ func XSetTimer(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XSetWindowLongPtrW(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XSetupComm(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XSleep(t *TLS, dwMilliseconds uint32) — windows/amd64

+ func XSleepEx(t *TLS, dwMilliseconds uint32, bAlertable int32) uint32 — windows/amd64

+ func XSystemTimeToFileTime(t *TLS, lpSystemTime, lpFileTime uintptr) int32 — windows/amd64

+ func XTerminateThread(t *TLS, hThread uintptr, dwExitCode uint32) int32 — windows/amd64

+ func XTranslateMessage(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XUnlockFile(t *TLS, hFile uintptr, ...) int32 — windows/amd64

+ func XUnlockFileEx(t *TLS, hFile uintptr, ...) int32 — windows/amd64

+ func XUnmapViewOfFile(t *TLS, lpBaseAddress uintptr) int32 — windows/amd64

+ func XUnregisterClassW(t *TLS, lpClassName, hInstance uintptr) int32 — windows/amd64

+ func XWSAAsyncSelect(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XWSAGetLastError(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XWSAStartup(t *TLS, wVersionRequired uint16, lpWSAData uintptr) int32 — windows/amd64

+ func XWaitForInputIdle(t *TLS, hProcess uintptr, dwMilliseconds uint32) int32 — windows/amd64

+ func XWaitForSingleObject(t *TLS, hHandle uintptr, dwMilliseconds uint32) uint32 — windows/amd64

+ func XWaitForSingleObjectEx(t *TLS, hHandle uintptr, dwMilliseconds uint32, bAlertable int32) uint32 — windows/amd64

+ func XWideCharToMultiByte(t *TLS, CodePage uint32, dwFlags uint32, lpWideCharStr uintptr, ...) int32 — windows/amd64

+ func XWriteConsoleW(t *TLS, hConsoleOutput, lpBuffer uintptr, nNumberOfCharsToWrite uint32, ...) int32 — windows/amd64

+ func XWriteFile(t *TLS, hFile, lpBuffer uintptr, nNumberOfBytesToWrite uint32, ...) int32 — windows/amd64

+ func XWspiapiFreeAddrInfo(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XWspiapiGetAddrInfo(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func XWspiapiGetNameInfo(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func X_IO_putc(t *TLS, c int32, fp uintptr) int32

+ func X_InterlockedCompareExchange(t *TLS, Destination uintptr, Exchange, Comparand long) long — windows/amd64

+ func X_InterlockedExchange(t *TLS, Target uintptr, Value long) long — windows/amd64

+ func X_NSGetEnviron(t *TLS) uintptr — darwin/amd64

+ func X___errno_location(t *TLS) uintptr

+ func X__acrt_iob_func(t *TLS, fd uint32) uintptr — windows/amd64

+ func X__assert_fail(t *TLS, assertion, file uintptr, line uint32, function uintptr)

+ func X__assert_rtn(t *TLS, function, file uintptr, line int32, assertion uintptr) — darwin/amd64

+ func X__atomic_load_n(t *TLS) — windows/amd64

+ func X__atomic_store_n(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func X__builtin___memcpy_chk(t *TLS, dest, src uintptr, n, os types.Size_t) (r uintptr)

+ func X__builtin___memmove_chk(t *TLS, dest, src uintptr, n, os types.Size_t) uintptr

+ func X__builtin___memset_chk(t *TLS, s uintptr, c int32, n, os types.Size_t) uintptr

+ func X__builtin___snprintf_chk(t *TLS, str uintptr, maxlen types.Size_t, flag int32, os types.Size_t, ...) (r int32)

+ func X__builtin___sprintf_chk(t *TLS, s uintptr, flag int32, os types.Size_t, format, args uintptr) (r int32)

+ func X__builtin___strcat_chk(t *TLS, dest, src uintptr, os types.Size_t) (r uintptr)

+ func X__builtin___strcpy_chk(t *TLS, dest, src uintptr, os types.Size_t) uintptr

+ func X__builtin___strncpy_chk(t *TLS, dest, src uintptr, n, os types.Size_t) (r uintptr)

+ func X__builtin___vsnprintf_chk(t *TLS, str uintptr, maxlen types.Size_t, flag int32, os types.Size_t, ...) (r int32)

+ func X__builtin_abort(t *TLS)

+ func X__builtin_abs(t *TLS, j int32) int32

+ func X__builtin_add_overflow(t *TLS) — windows/amd64

+ func X__builtin_add_overflowInt64(t *TLS, a, b int64, res uintptr) int32

+ func X__builtin_add_overflowUint32(t *TLS, a, b uint32, res uintptr) int32

+ func X__builtin_add_overflowUint64(t *TLS, a, b uint64, res uintptr) int32

+ func X__builtin_bswap16(t *TLS, x uint16) uint16

+ func X__builtin_bswap32(t *TLS, x uint32) uint32

+ func X__builtin_bswap64(t *TLS, x uint64) uint64

+ func X__builtin_bzero(t *TLS, s uintptr, n types.Size_t)

+ func X__builtin_clz(t *TLS, n uint32) int32

+ func X__builtin_clzl(t *TLS, n ulong) int32

+ func X__builtin_clzll(t *TLS, n uint64) int32

+ func X__builtin_constant_p_impl()

+ func X__builtin_copysign(t *TLS, x, y float64) float64

+ func X__builtin_copysignf(t *TLS, x, y float32) float32

+ func X__builtin_copysignl(t *TLS, x, y float64) float64

+ func X__builtin_exit(t *TLS, status int32)

+ func X__builtin_expect(t *TLS, exp, c long) long

+ func X__builtin_fabs(t *TLS, x float64) float64

+ func X__builtin_fabsf(t *TLS, x float32) float32

+ func X__builtin_fabsl(t *TLS, x float64) float64

+ func X__builtin_free(t *TLS, ptr uintptr)

+ func X__builtin_getentropy(t *TLS, buf uintptr, n types.Size_t) int32

+ func X__builtin_huge_val(t *TLS) float64

+ func X__builtin_huge_valf(t *TLS) float32

+ func X__builtin_inf(t *TLS) float64

+ func X__builtin_inff(t *TLS) float32

+ func X__builtin_infl(t *TLS) float64

+ func X__builtin_isnan(t *TLS, x float64) int32

+ func X__builtin_isunordered(t *TLS, a, b float64) int32

+ func X__builtin_llabs(tls *TLS, a int64) int64

+ func X__builtin_malloc(t *TLS, size types.Size_t) uintptr

+ func X__builtin_memcmp(t *TLS, s1, s2 uintptr, n types.Size_t) int32

+ func X__builtin_memcpy(t *TLS, dest, src uintptr, n types.Size_t) (r uintptr)

+ func X__builtin_memset(t *TLS, s uintptr, c int32, n types.Size_t) uintptr

+ func X__builtin_mmap(t *TLS, addr uintptr, length types.Size_t, prot, flags, fd int32, ...) uintptr

+ func X__builtin_mul_overflow(t *TLS) — windows/amd64

+ func X__builtin_mul_overflowInt64(t *TLS, a, b int64, res uintptr) int32

+ func X__builtin_mul_overflowUint128(t *TLS, a, b Uint128, res uintptr) int32

+ func X__builtin_mul_overflowUint64(t *TLS, a, b uint64, res uintptr) int32

+ func X__builtin_nan(t *TLS, s uintptr) float64

+ func X__builtin_nanf(t *TLS, s uintptr) float32

+ func X__builtin_nanl(t *TLS, s uintptr) float64

+ func X__builtin_object_size(t *TLS, p uintptr, typ int32) types.Size_t

+ func X__builtin_popcount(t *TLS, x uint32) int32

+ func X__builtin_popcountl(t *TLS, x ulong) int32

+ func X__builtin_prefetch(t *TLS, addr, args uintptr)

+ func X__builtin_printf(t *TLS, s, args uintptr) int32

+ func X__builtin_snprintf(t *TLS, str uintptr, size types.Size_t, format, args uintptr) int32

+ func X__builtin_sprintf(t *TLS, str, format, args uintptr) (r int32)

+ func X__builtin_strchr(t *TLS, s uintptr, c int32) uintptr

+ func X__builtin_strcmp(t *TLS, s1, s2 uintptr) int32

+ func X__builtin_strcpy(t *TLS, dest, src uintptr) uintptr

+ func X__builtin_strlen(t *TLS, s uintptr) types.Size_t

+ func X__builtin_sub_overflow(t *TLS) — windows/amd64

+ func X__builtin_sub_overflowInt64(t *TLS, a, b int64, res uintptr) int32

+ func X__builtin_trap(t *TLS)

+ func X__builtin_unreachable(t *TLS)

+ func X__ccgo_dmesg(t *TLS, fmt uintptr, va uintptr)

+ func X__ccgo_getMutexType(tls *TLS, m uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func X__ccgo_in6addr_anyp(t *TLS) uintptr — darwin/amd64, linux/amd64

+ func X__ccgo_in6addr_anyp(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func X__ccgo_pthreadAttrGetDetachState(tls *TLS, a uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func X__ccgo_pthreadMutexattrGettype(tls *TLS, a uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func X__ccgo_sqlite3_log(t *TLS, iErrCode int32, zFormat uintptr, args uintptr)

+ func X__cmsg_nxthdr(t *TLS, msgh, cmsg uintptr) uintptr — darwin/amd64, linux/amd64

+ func X__ctype_b_loc(tls *TLS) uintptr — linux/amd64

+ func X__ctype_get_mb_cur_max(t *TLS) types.Size_t

+ func X__darwin_fd_clr(tls *TLS, _fd int32, _p uintptr) int32 — darwin/amd64

+ func X__darwin_fd_isset(tls *TLS, _fd int32, _p uintptr) int32 — darwin/amd64

+ func X__darwin_fd_set(tls *TLS, _fd int32, _p uintptr) int32 — darwin/amd64

+ func X__env_rm_add(tls *TLS, old uintptr, new uintptr) — darwin/amd64, windows/amd64

+ func X__errno_location(t *TLS) uintptr

+ func X__error(t *TLS) uintptr — darwin/amd64

+ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) float64 — darwin/amd64, linux/amd64

+ func X__fpclassify(tls *TLS, x float64) int32 — darwin/amd64, linux/amd64

+ func X__fpclassifyf(tls *TLS, x float32) int32 — darwin/amd64, linux/amd64

+ func X__fpclassifyl(tls *TLS, x float64) int32 — darwin/amd64, linux/amd64

+ func X__h_errno_location(tls *TLS) uintptr — darwin/amd64, linux/amd64

+ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) int32 — darwin/amd64, linux/amd64

+ func X__inline_isnand(t *TLS, x float64) int32 — darwin/amd64

+ func X__inline_isnanf(t *TLS, x float32) int32 — darwin/amd64

+ func X__inline_isnanl(t *TLS, x float64) int32 — darwin/amd64

+ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) uint64 — darwin/amd64, linux/amd64

+ func X__isalnum_l(tls *TLS, c int32, l locale_t) int32 — linux/amd64, windows/amd64

+ func X__isalpha_l(tls *TLS, c int32, l locale_t) int32 — linux/amd64, windows/amd64

+ func X__isctype(tls *TLS, _c int32, _f uint64) int32 — darwin/amd64

+ func X__isdigit_l(tls *TLS, c int32, l locale_t) int32 — linux/amd64, windows/amd64

+ func X__islower_l(tls *TLS, c int32, l locale_t) int32 — linux/amd64, windows/amd64

+ func X__isnan(t *TLS, arg float64) int32

+ func X__isnanf(t *TLS, arg float32) int32

+ func X__isnanl(t *TLS, arg float64) int32

+ func X__isoc99_sscanf(t *TLS, str, format, va uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func X__isprint_l(tls *TLS, c int32, l locale_t) int32 — linux/amd64, windows/amd64

+ func X__isspace_l(tls *TLS, c int32, l locale_t) int32 — windows/amd64

+ func X__istype(tls *TLS, _c int32, _f uint64) int32 — darwin/amd64

+ func X__isupper_l(tls *TLS, c int32, l locale_t) int32 — linux/amd64

+ func X__isxdigit_l(tls *TLS, c int32, l locale_t) int32 — linux/amd64, windows/amd64

+ func X__lockfile(tls *TLS, f uintptr) int32 — linux/amd64

+ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) int32 — darwin/amd64, linux/amd64

+ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family int32, flags int32) int32 — darwin/amd64, linux/amd64

+ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype int32, flags int32) int32 — darwin/amd64, linux/amd64

+ func X__maskrune(tls *TLS, _c int32, _f uint64) int32 — darwin/amd64

+ func X__mingw_vfprintf(t *TLS, f uintptr, format, va uintptr) int32 — windows/amd64

+ func X__mingw_vfscanf(t *TLS, stream, format, ap uintptr) int32 — windows/amd64

+ func X__mingw_vfwprintf(t *TLS, stream, format, ap uintptr) int32 — windows/amd64

+ func X__mingw_vfwscanf(t *TLS, stream uintptr, format, ap uintptr) int32 — windows/amd64

+ func X__mingw_vprintf(t *TLS, s, ap uintptr) int32 — windows/amd64

+ func X__mingw_vsnprintf(t *TLS, str uintptr, size types.Size_t, format, ap uintptr) int32 — windows/amd64

+ func X__mingw_vsnwprintf(t *TLS, buffer uintptr, count types.Size_t, format, va uintptr) int32 — windows/amd64

+ func X__mingw_vsprintf(t *TLS, s, format, ap uintptr) int32 — windows/amd64

+ func X__mingw_vsscanf(t *TLS, str, format, ap uintptr) int32 — windows/amd64

+ func X__mingw_vswscanf(t *TLS, stream uintptr, format, ap uintptr) int32 — windows/amd64

+ func X__ms_vfscanf(t *TLS, stream, format, ap uintptr) int32 — windows/amd64

+ func X__ms_vfwscanf(t *TLS, stream uintptr, format, ap uintptr) int32 — windows/amd64

+ func X__ms_vscanf(t *TLS, format, ap uintptr) int32 — windows/amd64

+ func X__ms_vsnprintf(t *TLS, str uintptr, size types.Size_t, format, ap uintptr) int32 — windows/amd64

+ func X__ms_vsscanf(t *TLS, str, format, ap uintptr) int32 — windows/amd64

+ func X__ms_vswscanf(t *TLS, stream uintptr, format, ap uintptr) int32 — windows/amd64

+ func X__ms_vwscanf(t *TLS, format, ap uintptr) int32 — windows/amd64

+ func X__putenv(tls *TLS, s uintptr, l size_t, r uintptr) int32 — darwin/amd64, windows/amd64

+ func X__shgetc(tls *TLS, f uintptr) int32 — darwin/amd64, linux/amd64

+ func X__shlim(tls *TLS, f uintptr, lim off_t) — darwin/amd64, linux/amd64

+ func X__sincos_stret(t *TLS, f float64) struct — darwin/amd64

+ func X__sincosf_stret(t *TLS, f float32) struct — darwin/amd64

+ func X__sincospi_stret(t *TLS, f float64) struct — darwin/amd64

+ func X__sincospif_stret(t *TLS, f float32) struct — darwin/amd64

+ func X__srget(t *TLS, f uintptr) int32 — darwin/amd64

+ func X__stdio_common_vfprintf(t *TLS, args ...interface{}) int32 — windows/amd64

+ func X__stdio_common_vfprintf_p(t *TLS, args ...interface{}) int32 — windows/amd64

+ func X__stdio_common_vfprintf_s(t *TLS, args ...interface{}) int32 — windows/amd64

+ func X__stdio_common_vfscanf(t *TLS, args ...interface{}) int32 — windows/amd64

+ func X__stdio_common_vfwprintf_s(t *TLS, args ...interface{}) int32 — windows/amd64

+ func X__stdio_common_vfwscanf(t *TLS, args ...interface{}) int32 — windows/amd64

+ func X__stdio_common_vsnprintf_s(t *TLS, args ...interface{}) int32 — windows/amd64

+ func X__stdio_common_vsnwprintf_s(t *TLS, args ...interface{}) int32 — windows/amd64

+ func X__stdio_common_vsprintf(t *TLS, args ...interface{}) int32 — windows/amd64

+ func X__stdio_common_vsprintf_p(t *TLS, args ...interface{}) int32 — windows/amd64

+ func X__stdio_common_vsprintf_s(t *TLS, args ...interface{}) int32 — windows/amd64

+ func X__stdio_common_vsscanf(t *TLS, args ...interface{}) int32 — windows/amd64

+ func X__stdio_common_vswprintf(t *TLS, args ...interface{}) int32 — windows/amd64

+ func X__stdio_common_vswprintf_s(t *TLS, args ...interface{}) int32 — windows/amd64

+ func X__stdio_common_vswscanf(t *TLS, args ...interface{}) int32 — windows/amd64

+ func X__strchrnul(tls *TLS, s uintptr, c int32) uintptr — darwin/amd64, windows/amd64

+ func X__strncasecmp_l(tls *TLS, l uintptr, r uintptr, n size_t, loc locale_t) int32 — darwin/amd64, linux/amd64

+ func X__svfscanf(t *TLS, f uintptr, p, q uintptr) int32 — darwin/amd64

+ func X__swbuf(t *TLS, i int32, f uintptr) int32 — darwin/amd64

+ func X__sync_add_and_fetch_uint32(t *TLS, p uintptr, v uint32) uint32

+ func X__sync_sub_and_fetch_uint32(t *TLS, p uintptr, v uint32) uint32

+ func X__sync_synchronize(t *TLS)

+ func X__syscall1(t *TLS, trap, p1 long) long — linux/amd64

+ func X__syscall3(t *TLS, trap, p1, p2, p3 long) long — linux/amd64

+ func X__syscall4(t *TLS, trap, p1, p2, p3, p4 long) long — linux/amd64

+ func X__tolower(tls *TLS, c int32) int32 — darwin/amd64

+ func X__toread(tls *TLS, f uintptr) int32 — darwin/amd64, linux/amd64

+ func X__toread_needs_stdio_exit(tls *TLS) — darwin/amd64, linux/amd64

+ func X__toupper(tls *TLS, c int32) int32 — darwin/amd64

+ func X__uflow(tls *TLS, f uintptr) int32 — darwin/amd64, linux/amd64

+ func X__unlockfile(tls *TLS, f uintptr) — linux/amd64

+ func X__wcwidth(tls *TLS, _c int32) int32 — darwin/amd64

+ func X_access(t *TLS, pathname uintptr, mode int32) int32 — windows/amd64

+ func X_assert(t *TLS, message, filename uintptr, line uint32) — windows/amd64

+ func X_beginthread(t *TLS, procAddr uintptr, stack_sz uint32, args uintptr) int32 — windows/amd64

+ func X_beginthreadex(t *TLS, _ uintptr, stack_sz uint32, procAddr uintptr, args uintptr, ...) int32 — windows/amd64

+ func X_byteswap_uint64(t *TLS, val uint64) uint64 — windows/amd64

+ func X_byteswap_ulong(t *TLS, val ulong) ulong — windows/amd64

+ func X_chmod(t *TLS, filename uintptr, pmode int32) int32 — windows/amd64

+ func X_chsize(t *TLS, fd int32, size long) int32 — windows/amd64

+ func X_commit(t *TLS, fd int32) int32 — windows/amd64

+ func X_controlfp(t *TLS, _ ...interface{}) uint32 — windows/amd64

+ func X_copysign(t *TLS, x, y float64) float64 — windows/amd64

+ func X_endthreadex(t *TLS, _ ...interface{}) — windows/amd64

+ func X_errno(t *TLS) uintptr — windows/amd64

+ func X_exit(_ *TLS, status int32)

+ func X_fileno(t *TLS, stream uintptr) int32 — windows/amd64

+ func X_findclose(t *TLS, handle types.Intptr_t) int32 — windows/amd64

+ func X_findfirst32(t *TLS, filespec, fileinfo uintptr) types.Intptr_t — windows/amd64

+ func X_findfirst64i32(t *TLS, filespec, fileinfo uintptr) types.Intptr_t — windows/amd64

+ func X_findnext32(t *TLS, handle types.Intptr_t, buffer uintptr) int32 — windows/amd64

+ func X_findnext64i32(t *TLS, handle types.Intptr_t, fileinfo uintptr) int32 — windows/amd64

+ func X_fstat64(t *TLS, fd int32, buffer uintptr) int32 — windows/amd64

+ func X_fstati64(t *TLS, fd int32, buffer uintptr) int32 — windows/amd64

+ func X_ftime(t *TLS, timeptr uintptr) — windows/amd64

+ func X_ftime64(t *TLS, timeptr uintptr) — windows/amd64

+ func X_gmtime64(t *TLS, sourceTime uintptr) uintptr — windows/amd64

+ func X_isatty(t *TLS, fd int32) int32 — windows/amd64

+ func X_localtime64(_ *TLS, timep uintptr) uintptr — windows/amd64

+ func X_longjmp(t *TLS, env uintptr, val int32)

+ func X_mkdir(t *TLS, dirname uintptr) int32 — windows/amd64

+ func X_mktime64(t *TLS, timeptr uintptr) time.X__time64_t — windows/amd64

+ func X_msize(t *TLS, memblock uintptr) types.Size_t — windows/amd64

+ func X_obstack_begin(t *TLS, obstack uintptr, size, alignment int32, chunkfun, freefun uintptr) int32

+ func X_obstack_newchunk(t *TLS, obstack uintptr, length int32) int32

+ func X_pclose(t *TLS, stream uintptr) int32 — windows/amd64

+ func X_popen(t *TLS, command, mode uintptr) uintptr — windows/amd64

+ func X_putchar(t *TLS, c int32) int32 — windows/amd64

+ func X_set_abort_behavior(t *TLS, _ ...interface{}) uint32 — windows/amd64

+ func X_setjmp(t *TLS, env uintptr) int32

+ func X_setmode(t *TLS, fd, mode int32) int32 — windows/amd64

+ func X_snprintf(t *TLS, str uintptr, size types.Size_t, format, args uintptr) int32 — windows/amd64

+ func X_snwprintf(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func X_stat64(t *TLS, path, buffer uintptr) int32 — windows/amd64

+ func X_stati64(t *TLS, path, buffer uintptr) int32 — windows/amd64

+ func X_strdup(t *TLS, s uintptr) uintptr — windows/amd64

+ func X_stricmp(t *TLS, string1, string2 uintptr) int32 — windows/amd64

+ func X_strnicmp(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func X_unlink(t *TLS, filename uintptr) int32 — windows/amd64

+ func X_vsnwprintf(t *TLS, buffer uintptr, count types.Size_t, format, ap uintptr) int32 — windows/amd64

+ func X_wcsicmp(t *TLS, string1, string2 uintptr) int32 — windows/amd64

+ func X_wcsnicmp(t *TLS, string1, string2 uintptr, count types.Size_t) int32 — windows/amd64

+ func X_wgetenv(t *TLS, varname uintptr) uintptr — windows/amd64

+ func X_wopen(t *TLS, pathname uintptr, flags int32, args uintptr) int32 — windows/amd64

+ func X_wputenv(t *TLS, envstring uintptr) int32 — windows/amd64

+ func X_wtoi(t *TLS, str uintptr) int32 — windows/amd64

+ func X_wunlink(t *TLS, filename uintptr) int32 — windows/amd64

+ func Xabort(t *TLS) — darwin/amd64, linux/amd64, windows/amd64

+ func Xabs(t *TLS, j int32) int32

+ func Xaccept(t *TLS, sockfd int32, addr uintptr, addrlen uintptr) int32 — darwin/amd64, linux/amd64

+ func Xaccept(t *TLS, sockfd uint64, addr uintptr, addrlen uintptr) uint64 — windows/amd64

+ func Xaccess(t *TLS, pathname uintptr, mode int32) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xacos(t *TLS, x float64) float64

+ func Xacosh(t *TLS, x float64) float64

+ func Xalarm(t *TLS, seconds uint32) uint32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xarc4random_buf(t *TLS, buf uintptr, buflen size_t) — darwin/amd64

+ func Xasin(t *TLS, x float64) float64

+ func Xasinh(t *TLS, x float64) float64

+ func Xatan(t *TLS, x float64) float64

+ func Xatan2(t *TLS, x, y float64) float64

+ func Xatanh(t *TLS, x float64) float64

+ func Xatexit(t *TLS, function uintptr) int32

+ func Xatof(t *TLS, nptr uintptr) float64

+ func Xatoi(t *TLS, nptr uintptr) int32

+ func Xatol(t *TLS, nptr uintptr) long

+ func Xbacktrace(t *TLS, buf uintptr, size int32) int32 — linux/amd64, windows/amd64

+ func Xbacktrace_symbols_fd(t *TLS, buffer uintptr, size, fd int32) — linux/amd64, windows/amd64

+ func Xbind(t *TLS, sockfd int32, addr uintptr, addrlen uint32) int32 — darwin/amd64, linux/amd64

+ func Xbind(t *TLS, sockfd uint64, addr uintptr, addrlen int32) int32 — windows/amd64

+ func Xbsearch(tls *TLS, key uintptr, base uintptr, nel size_t, width size_t, cmp uintptr) uintptr — darwin/amd64, linux/amd64, windows/amd64

+ func Xbzero(t *TLS, s uintptr, n types.Size_t)

+ func Xcalloc(t *TLS, n, size types.Size_t) uintptr

+ func Xceil(t *TLS, x float64) float64

+ func Xceilf(t *TLS, x float32) float32

+ func Xcfgetospeed(t *TLS, termios_p uintptr) termios.Speed_t — darwin/amd64, linux/amd64

+ func Xcfsetispeed(...interface{}) int32 — darwin/amd64

+ func Xcfsetispeed(t *TLS, termios_p uintptr, speed uint32) int32 — linux/amd64, windows/amd64

+ func Xcfsetospeed(...interface{}) int32 — darwin/amd64

+ func Xcfsetospeed(t *TLS, termios_p uintptr, speed uint32) int32 — linux/amd64, windows/amd64

+ func Xchdir(t *TLS, path uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xchflags(t *TLS, path uintptr, flags uint32) int32 — darwin/amd64

+ func Xchmod(t *TLS, pathname uintptr, mode int32) int32 — windows/amd64

+ func Xchmod(t *TLS, pathname uintptr, mode types.Mode_t) int32 — darwin/amd64, linux/amd64

+ func Xchown(t *TLS, pathname uintptr, owner types.Uid_t, group types.Gid_t) int32 — darwin/amd64, linux/amd64

+ func Xclock(t *TLS) time.Clock_t — darwin/amd64

+ func Xclock_gettime(t *TLS, clk_id int32, tp uintptr) int32

+ func Xclose(t *TLS, fd int32) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xclosedir(t *TLS, dir uintptr) int32 — darwin/amd64

+ func Xclosedir(tls *TLS, dir uintptr) int32 — linux/amd64, windows/amd64

+ func Xclosesocket(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func Xconfstr(t *TLS, name int32, buf uintptr, len types.Size_t) types.Size_t

+ func Xconnect(t *TLS, sockfd int32, addr uintptr, addrlen uint32) int32 — darwin/amd64, linux/amd64

+ func Xconnect(t *TLS, sockfd uint64, addr uintptr, addrlen int32) int32 — windows/amd64

+ func Xcopyfile(...interface{}) int32 — darwin/amd64

+ func Xcopysign(t *TLS, x, y float64) float64

+ func Xcopysignf(t *TLS, x, y float32) float32

+ func Xcopysignl(tls *TLS, x float64, y float64) float64 — darwin/amd64, linux/amd64

+ func Xcos(t *TLS, x float64) float64

+ func Xcosf(t *TLS, x float32) float32

+ func Xcosh(t *TLS, x float64) float64

+ func Xctime(t *TLS, timep uintptr) uintptr — darwin/amd64, linux/amd64

+ func Xctime_r(t *TLS, timep, buf uintptr) uintptr — darwin/amd64, linux/amd64

+ func Xdigittoint(tls *TLS, _c int32) int32 — darwin/amd64

+ func Xdlclose(t *TLS, handle uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xdlerror(t *TLS) uintptr — darwin/amd64, linux/amd64, windows/amd64

+ func Xdlopen(t *TLS, filename uintptr, flags int32) uintptr — darwin/amd64, linux/amd64, windows/amd64

+ func Xdlsym(t *TLS, handle, symbol uintptr) uintptr — darwin/amd64, linux/amd64, windows/amd64

+ func Xdup2(t *TLS, oldfd, newfd int32) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xdup3(t *TLS, oldfd int32, newfd int32, flags int32) int32 — linux/amd64

+ func Xendpwent(t *TLS) — darwin/amd64, linux/amd64

+ func Xexecvp(t *TLS, file, argv uintptr) int32 — linux/amd64, windows/amd64

+ func Xexit(t *TLS, status int32)

+ func Xexp(t *TLS, x float64) float64

+ func Xfabs(t *TLS, x float64) float64

+ func Xfabsf(t *TLS, x float32) float32

+ func Xfabsl(t *TLS, x float64) float64 — windows/amd64

+ func Xfabsl(tls *TLS, x float64) float64 — darwin/amd64, linux/amd64

+ func Xfaccessat(t *TLS, dirfd int32, pathname uintptr, mode, flags int32) int32 — linux/amd64

+ func Xfchmod(t *TLS, fd int32, mode types.Mode_t) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xfchmodat(t *TLS, dirfd int32, pathname uintptr, mode types.Mode_t, flags int32) int32 — linux/amd64

+ func Xfchown(t *TLS, fd int32, owner types.Uid_t, group types.Gid_t) int32 — darwin/amd64, linux/amd64

+ func Xfchownat(t *TLS, dirfd int32, pathname uintptr, uid types.Uid_t, gid types.Gid_t, ...) int32 — linux/amd64

+ func Xfclose(t *TLS, stream uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xfcntl(t *TLS, fd, cmd int32, args uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xfcntl64(t *TLS, fd, cmd int32, args uintptr) (r int32) — darwin/amd64

+ func Xfcntl64(t *TLS, fd, cmd int32, args uintptr) int32 — linux/amd64, windows/amd64

+ func Xfdopen(t *TLS, fd int32, mode uintptr) uintptr — darwin/amd64, linux/amd64, windows/amd64

+ func Xferror(t *TLS, stream uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xfflush(t *TLS, stream uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xfgetc(t *TLS, stream uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xfgets(t *TLS, s uintptr, size int32, stream uintptr) uintptr

+ func Xfileno(t *TLS, stream uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xflock(t *TLS, fd, operation int32) int32 — darwin/amd64

+ func Xfloor(t *TLS, x float64) float64

+ func Xfmod(t *TLS, x, y float64) float64

+ func Xfmodl(tls *TLS, x float64, y float64) float64 — darwin/amd64, linux/amd64

+ func Xfopen(t *TLS, pathname, mode uintptr) uintptr

+ func Xfopen64(t *TLS, pathname, mode uintptr) uintptr — darwin/amd64, linux/amd64, windows/amd64

+ func Xfork(t *TLS) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xfprintf(t *TLS, stream, format, args uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xfputc(t *TLS, c int32, stream uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xfputs(t *TLS, s, stream uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xfread(t *TLS, ptr uintptr, size, nmemb types.Size_t, stream uintptr) types.Size_t — darwin/amd64, linux/amd64, windows/amd64

+ func Xfree(t *TLS, p uintptr)

+ func Xfreeaddrinfo(tls *TLS, p uintptr) — darwin/amd64, linux/amd64

+ func Xfrexp(t *TLS, x float64, exp uintptr) float64

+ func Xfscanf(t *TLS, stream, format, va uintptr) int32 — linux/amd64, windows/amd64

+ func Xfsctl(t *TLS, path uintptr, request ulong, data uintptr, options uint32) int32 — darwin/amd64

+ func Xfseek(t *TLS, stream uintptr, offset long, whence int32) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xfstat(t *TLS, fd int32, statbuf uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xfstat64(t *TLS, fd int32, statbuf uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xfstatfs(t *TLS, fd int32, buf uintptr) int32 — darwin/amd64, linux/amd64

+ func Xfsync(t *TLS, fd int32) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xftell(t *TLS, stream uintptr) long — darwin/amd64, linux/amd64, windows/amd64

+ func Xftruncate(t *TLS, fd int32, length types.Off_t) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xftruncate64(t *TLS, fd int32, length types.Off_t) int32 — linux/amd64, windows/amd64

+ func Xfts64_close(t *TLS, ftsp uintptr) int32 — linux/amd64, windows/amd64

+ func Xfts64_open(t *TLS, path_argv uintptr, options int32, compar uintptr) uintptr — linux/amd64, windows/amd64

+ func Xfts64_read(t *TLS, ftsp uintptr) uintptr — linux/amd64, windows/amd64

+ func Xfts_close(t *TLS, ftsp uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xfts_open(t *TLS, path_argv uintptr, options int32, compar uintptr) uintptr — darwin/amd64, linux/amd64

+ func Xfts_read(t *TLS, ftsp uintptr) uintptr — darwin/amd64, linux/amd64, windows/amd64

+ func Xfutimes(t *TLS, fd int32, tv uintptr) int32 — darwin/amd64

+ func Xfwrite(t *TLS, ptr uintptr, size, nmemb types.Size_t, stream uintptr) types.Size_t — darwin/amd64, linux/amd64, windows/amd64

+ func Xgai_strerror(t *TLS, errcode int32) uintptr — darwin/amd64, linux/amd64, windows/amd64

+ func Xgai_strerrorA(t *TLS, ecode int32) uintptr — windows/amd64

+ func Xgai_strerrorW(t *TLS, _ ...interface{}) uintptr — windows/amd64

+ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintptr) int32 — darwin/amd64, linux/amd64

+ func Xgetattrlist(t *TLS, path, attrList, attrBuf uintptr, attrBufSize types.Size_t, ...) int32 — darwin/amd64

+ func Xgetc(t *TLS, stream uintptr) int32

+ func Xgetcwd(t *TLS, buf uintptr, size types.Size_t) uintptr — darwin/amd64, linux/amd64, windows/amd64

+ func Xgetegid(t *TLS) types.Gid_t — darwin/amd64, linux/amd64

+ func Xgetentropy(t *TLS, buffer uintptr, length size_t) int32

+ func Xgetenv(t *TLS, name uintptr) uintptr

+ func Xgeteuid(t *TLS) types.Uid_t — darwin/amd64, linux/amd64

+ func Xgetgid(t *TLS) types.Gid_t — darwin/amd64, linux/amd64

+ func Xgetgrgid(t *TLS, gid uint32) uintptr — darwin/amd64, linux/amd64

+ func Xgetgrgid_r(t *TLS, gid uint32, pGrp, buf uintptr, buflen types.Size_t, result uintptr) int32 — darwin/amd64, linux/amd64

+ func Xgetgrnam(t *TLS, name uintptr) uintptr — darwin/amd64, linux/amd64

+ func Xgetgrnam_r(t *TLS, name, pGrp, buf uintptr, buflen types.Size_t, result uintptr) int32 — darwin/amd64, linux/amd64

+ func Xgethostbyaddr(tls *TLS, a uintptr, l socklen_t, af int32) uintptr — darwin/amd64, linux/amd64

+ func Xgethostbyaddr_r(tls *TLS, a uintptr, l socklen_t, af int32, h uintptr, buf uintptr, ...) int32 — darwin/amd64, linux/amd64

+ func Xgethostbyname(tls *TLS, name uintptr) uintptr — darwin/amd64, linux/amd64

+ func Xgethostbyname2(tls *TLS, name uintptr, af int32) uintptr — darwin/amd64, linux/amd64

+ func Xgethostbyname2_r(tls *TLS, name uintptr, af int32, h uintptr, buf uintptr, buflen size_t, ...) int32 — darwin/amd64, linux/amd64

+ func Xgethostbyname_r(tls *TLS, name uintptr, h uintptr, buf uintptr, buflen size_t, res uintptr, ...) int32 — linux/amd64

+ func Xgethostname(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func Xgethostname(t *TLS, name uintptr, slen types.Size_t) int32 — darwin/amd64, linux/amd64

+ func Xgethostuuid(t *TLS, id uintptr, wait uintptr) int32 — darwin/amd64

+ func Xgetnameinfo(tls *TLS, sa1 uintptr, sl socklen_t, node uintptr, nodelen socklen_t, ...) int32 — darwin/amd64, linux/amd64

+ func Xgetpeername(t *TLS, sockfd int32, addr uintptr, addrlen uintptr) int32 — darwin/amd64, linux/amd64

+ func Xgetpeername(t *TLS, sockfd uint64, addr uintptr, addrlen uintptr) int32 — windows/amd64

+ func Xgetpid(t *TLS) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xgetprogname(t *TLS) uintptr — darwin/amd64

+ func Xgetpwnam(t *TLS, name uintptr) uintptr — darwin/amd64, linux/amd64

+ func Xgetpwnam_r(t *TLS, name, cpwd, buf uintptr, buflen types.Size_t, result uintptr) int32 — darwin/amd64, linux/amd64

+ func Xgetpwuid(t *TLS, uid uint32) uintptr — darwin/amd64, linux/amd64, windows/amd64

+ func Xgetpwuid_r(t *TLS, uid types.Uid_t, cpwd, buf uintptr, buflen types.Size_t, ...) int32 — darwin/amd64, linux/amd64

+ func Xgetrandom(t *TLS, buf uintptr, buflen size_t, flags uint32) ssize_t — linux/amd64

+ func Xgetresgid(t *TLS, rgid, egid, sgid uintptr) int32 — darwin/amd64, linux/amd64

+ func Xgetresuid(t *TLS, ruid, euid, suid uintptr) int32 — darwin/amd64, linux/amd64

+ func Xgetrlimit(t *TLS, resource int32, rlim uintptr) int32 — linux/amd64, windows/amd64

+ func Xgetrlimit64(t *TLS, resource int32, rlim uintptr) int32 — linux/amd64, windows/amd64

+ func Xgetrusage(t *TLS, who int32, usage uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xgetservbyname(t *TLS, _ ...interface{}) uintptr — windows/amd64

+ func Xgetservbyname(t *TLS, name, proto uintptr) uintptr — darwin/amd64, linux/amd64

+ func Xgetsockname(t *TLS, sockfd int32, addr, addrlen uintptr) int32 — darwin/amd64, linux/amd64

+ func Xgetsockname(t *TLS, sockfd uint64, addr, addrlen uintptr) int32 — windows/amd64

+ func Xgetsockopt(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func Xgetsockopt(t *TLS, sockfd, level, optname int32, optval, optlen uintptr) int32 — darwin/amd64, linux/amd64

+ func Xgettimeofday(t *TLS, tv, tz uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xgetuid(t *TLS) types.Uid_t — darwin/amd64, linux/amd64

+ func Xgmtime(t *TLS, _ ...interface{}) uintptr — windows/amd64

+ func Xgmtime_r(t *TLS, timep, result uintptr) uintptr — darwin/amd64, linux/amd64, windows/amd64

+ func Xhtonl(t *TLS, hostlong uint32) uint32

+ func Xhtons(t *TLS, hostshort uint16) uint16

+ func Xhypot(t *TLS, x, y float64) float64

+ func Xinet_ntoa(t *TLS, _ ...interface{}) uintptr — windows/amd64

+ func Xinet_ntoa(t *TLS, in1 in.In_addr) uintptr — darwin/amd64, linux/amd64

+ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l socklen_t) uintptr — darwin/amd64, linux/amd64

+ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) int32 — darwin/amd64, linux/amd64

+ func Xinitstate(t *TLS, seed uint32, statebuf uintptr, statelen types.Size_t) uintptr — darwin/amd64, linux/amd64

+ func Xinitstate_r(t *TLS, seed uint32, statebuf uintptr, statelen types.Size_t, buf uintptr) int32 — darwin/amd64, linux/amd64

+ func Xioctl(t *TLS, fd int32, request ulong, va uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xioctlsocket(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func Xisalnum(tls *TLS, _c int32) int32 — darwin/amd64

+ func Xisalnum(tls *TLS, c int32) int32 — linux/amd64, windows/amd64

+ func Xisalpha(tls *TLS, _c int32) int32 — darwin/amd64

+ func Xisalpha(tls *TLS, c int32) int32 — linux/amd64, windows/amd64

+ func Xisascii(t *TLS, c int32) int32

+ func Xisatty(t *TLS, fd int32) int32

+ func Xisblank(tls *TLS, _c int32) int32 — darwin/amd64

+ func Xiscntrl(tls *TLS, _c int32) int32 — darwin/amd64

+ func Xisdigit(tls *TLS, _c int32) int32 — darwin/amd64

+ func Xisdigit(tls *TLS, c int32) int32 — linux/amd64, windows/amd64

+ func Xisgraph(tls *TLS, _c int32) int32 — darwin/amd64

+ func Xishexnumber(tls *TLS, _c int32) int32 — darwin/amd64

+ func Xisideogram(tls *TLS, _c int32) int32 — darwin/amd64

+ func Xislower(tls *TLS, _c int32) int32 — darwin/amd64

+ func Xislower(tls *TLS, c int32) int32 — linux/amd64, windows/amd64

+ func Xisnan(t *TLS, x float64) int32

+ func Xisnanf(t *TLS, x float32) int32

+ func Xisnanl(t *TLS, x float64) int32

+ func Xisnumber(tls *TLS, _c int32) int32 — darwin/amd64

+ func Xisphonogram(tls *TLS, _c int32) int32 — darwin/amd64

+ func Xisprint(tls *TLS, _c int32) int32 — darwin/amd64

+ func Xisprint(tls *TLS, c int32) int32 — linux/amd64, windows/amd64

+ func Xispunct(tls *TLS, _c int32) int32 — darwin/amd64

+ func Xisrune(tls *TLS, _c int32) int32 — darwin/amd64

+ func Xissetugid(t *TLS) int32 — darwin/amd64

+ func Xisspace(t *TLS, c int32) int32 — darwin/amd64

+ func Xisspace(tls *TLS, c int32) int32 — windows/amd64

+ func Xisspecial(tls *TLS, _c int32) int32 — darwin/amd64

+ func Xisupper(tls *TLS, _c int32) int32 — darwin/amd64

+ func Xisupper(tls *TLS, c int32) int32 — linux/amd64

+ func Xiswalnum(t *TLS, wc wctype.Wint_t) int32 — darwin/amd64, linux/amd64

+ func Xiswspace(t *TLS, wc wctype.Wint_t) int32 — darwin/amd64, linux/amd64

+ func Xisxdigit(tls *TLS, _c int32) int32 — darwin/amd64

+ func Xisxdigit(tls *TLS, c int32) int32 — linux/amd64, windows/amd64

+ func Xkill(t *TLS, pid types.Pid_t, sig int32) int32

+ func Xldexp(t *TLS, x float64, exp int32) float64

+ func Xlink(t *TLS, oldpath, newpath uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xlinkat(t *TLS, olddirfd int32, oldpath uintptr, newdirfd int32, newpath uintptr, ...) int32 — linux/amd64

+ func Xlisten(t *TLS, sockfd uint64, backlog int32) int32 — windows/amd64

+ func Xlisten(t *TLS, sockfd, backlog int32) int32 — darwin/amd64, linux/amd64

+ func Xllabs(tls *TLS, a int64) int64

+ func Xlocaleconv(tls *TLS) uintptr — darwin/amd64, linux/amd64

+ func Xlocaltime(_ *TLS, timep uintptr) uintptr — darwin/amd64, linux/amd64, windows/amd64

+ func Xlocaltime_r(_ *TLS, timep, result uintptr) uintptr — darwin/amd64, linux/amd64, windows/amd64

+ func Xlog(t *TLS, x float64) float64

+ func Xlog10(t *TLS, x float64) float64

+ func Xlog2(t *TLS, x float64) float64

+ func Xlongjmp(t *TLS, env uintptr, val int32)

+ func Xlrand48(t *TLS) long — darwin/amd64, linux/amd64

+ func Xlseek(t *TLS, fd int32, offset types.Off_t, whence int32) types.Off_t — darwin/amd64, linux/amd64, windows/amd64

+ func Xlseek64(t *TLS, fd int32, offset types.Off_t, whence int32) types.Off_t — darwin/amd64, linux/amd64, windows/amd64

+ func Xlstat(t *TLS, pathname, statbuf uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xlstat64(t *TLS, pathname, statbuf uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func XlstrcmpiA(t *TLS, lpString1, lpString2 uintptr) int32 — windows/amd64

+ func XlstrlenW(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func Xmach_absolute_time(t *TLS) uint64 — darwin/amd64

+ func Xmach_timebase_info(t *TLS, info uintptr) int32 — darwin/amd64

+ func Xmalloc(t *TLS, n types.Size_t) uintptr

+ func Xmblen(t *TLS, s uintptr, n types.Size_t) int32

+ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n size_t, st uintptr) size_t — linux/amd64

+ func Xmbsinit(tls *TLS, st uintptr) int32 — linux/amd64

+ func Xmbstowcs(t *TLS, dest, src uintptr, n types.Size_t) types.Size_t

+ func Xmbtowc(t *TLS, pwc, s uintptr, n types.Size_t) int32

+ func Xmemchr(t *TLS, s uintptr, c int32, n types.Size_t) uintptr

+ func Xmemcmp(t *TLS, s1, s2 uintptr, n types.Size_t) int32

+ func Xmemcpy(t *TLS, dest, src uintptr, n types.Size_t) (r uintptr)

+ func Xmemmove(t *TLS, dest, src uintptr, n types.Size_t) uintptr

+ func Xmemset(t *TLS, s uintptr, c int32, n types.Size_t) uintptr

+ func Xmkdir(t *TLS, path uintptr, mode types.Mode_t) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xmkdirat(t *TLS, dirfd int32, pathname uintptr, mode types.Mode_t) int32 — linux/amd64

+ func Xmkfifo(t *TLS, pathname uintptr, mode types.Mode_t) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xmknod(t *TLS, pathname uintptr, mode types.Mode_t, dev types.Dev_t) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xmknodat(t *TLS, dirfd int32, pathname uintptr, mode types.Mode_t, dev types.Dev_t) int32 — linux/amd64

+ func Xmkostemp(t *TLS, template uintptr, flags int32) int32 — darwin/amd64, linux/amd64

+ func Xmkstemp(t *TLS, template uintptr) int32 — darwin/amd64, linux/amd64

+ func Xmkstemp64(t *TLS, template uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xmkstemps(t *TLS, template uintptr, suffixlen int32) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xmkstemps64(t *TLS, template uintptr, suffixlen int32) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xmktime(t *TLS, ptm uintptr) time.Time_t

+ func Xmmap(t *TLS, addr uintptr, length types.Size_t, prot, flags, fd int32, ...) uintptr — darwin/amd64, linux/amd64, windows/amd64

+ func Xmmap64(t *TLS, addr uintptr, length types.Size_t, prot, flags, fd int32, ...) uintptr — linux/amd64, windows/amd64

+ func Xmodf(t *TLS, x float64, iptr uintptr) float64

+ func Xmremap(t *TLS, old_address uintptr, old_size, new_size types.Size_t, flags int32, ...) uintptr — linux/amd64, windows/amd64

+ func Xmunmap(t *TLS, addr uintptr, length types.Size_t) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xnanf(tls *TLS, s uintptr) float32 — darwin/amd64, linux/amd64

+ func Xnanosleep(t *TLS, req, rem uintptr) int32 — linux/amd64

+ func Xnl_langinfo(t *TLS, item langinfo.Nl_item) uintptr — darwin/amd64, linux/amd64

+ func Xntohs(t *TLS, netshort uint16) uint16

+ func Xobstack_free(t *TLS, obstack, obj uintptr)

+ func Xobstack_vprintf(t *TLS, obstack, template, va uintptr) int32

+ func Xopen(t *TLS, pathname uintptr, flags int32, args uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xopen64(t *TLS, pathname uintptr, flags int32, args uintptr) int32 — linux/amd64

+ func Xopen64(t *TLS, pathname uintptr, flags int32, cmode uintptr) int32 — windows/amd64

+ func Xopenat(t *TLS, dirfd int32, pathname uintptr, flags int32, mode types.Mode_t) int32 — linux/amd64

+ func Xopendir(t *TLS, name uintptr) uintptr — darwin/amd64

+ func Xopendir(tls *TLS, name uintptr) uintptr — linux/amd64, windows/amd64

+ func Xopenpty(t *TLS, amaster, aslave, name, termp, winp uintptr) int32

+ func Xpathconf(t *TLS, path uintptr, name int32) long — darwin/amd64, linux/amd64

+ func Xpause(t *TLS) int32 — darwin/amd64, linux/amd64

+ func Xpclose(t *TLS, stream uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xperror(t *TLS, s uintptr) — darwin/amd64, linux/amd64, windows/amd64

+ func Xpipe(t *TLS, pipefd uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xpipe2(t *TLS, pipefd uintptr, flags int32) int32 — linux/amd64

+ func Xpoll(t *TLS, fds uintptr, nfds poll.Nfds_t, timeout int32) int32 — darwin/amd64, linux/amd64

+ func Xpopen(t *TLS, command, type1 uintptr) uintptr — darwin/amd64, linux/amd64, windows/amd64

+ func Xposix_fadvise(t *TLS, fd int32, offset, len types.Off_t, advice int32) int32 — darwin/amd64, linux/amd64

+ func Xpow(t *TLS, x, y float64) float64

+ func Xpread(t *TLS, fd int32, buf uintptr, count types.Size_t, offset types.Off_t) types.Ssize_t — darwin/amd64

+ func Xprintf(t *TLS, format, args uintptr) int32

+ func Xpselect(t *TLS, nfds int32, readfds, writefds, exceptfds, timeout, sigmask uintptr) int32

+ func Xpthread_attr_destroy(t *TLS, pAttr uintptr) int32

+ func Xpthread_attr_getdetachstate(tls *TLS, a uintptr, state uintptr) int32 — darwin/amd64, linux/amd64

+ func Xpthread_attr_init(t *TLS, pAttr uintptr) int32

+ func Xpthread_attr_setdetachstate(tls *TLS, a uintptr, state int32) int32 — darwin/amd64, linux/amd64

+ func Xpthread_attr_setscope(t *TLS, pAttr uintptr, contentionScope int32) int32

+ func Xpthread_attr_setstacksize(t *TLS, attr uintptr, stackSize types.Size_t) int32

+ func Xpthread_cond_broadcast(t *TLS, pCond uintptr) int32

+ func Xpthread_cond_destroy(t *TLS, pCond uintptr) int32

+ func Xpthread_cond_init(t *TLS, pCond, pAttr uintptr) int32

+ func Xpthread_cond_signal(t *TLS, pCond uintptr) int32

+ func Xpthread_cond_timedwait(t *TLS, pCond, pMutex, pAbsTime uintptr) int32

+ func Xpthread_cond_wait(t *TLS, pCond, pMutex uintptr) int32

+ func Xpthread_create(t *TLS, pThread, pAttr, startRoutine, arg uintptr) int32

+ func Xpthread_detach(t *TLS, thread pthread.Pthread_t) int32

+ func Xpthread_equal(t *TLS, t1, t2 pthread.Pthread_t) int32

+ func Xpthread_exit(t *TLS, value uintptr)

+ func Xpthread_getspecific(t *TLS, key pthread.Pthread_key_t) uintptr

+ func Xpthread_join(t *TLS, thread pthread.Pthread_t, pValue uintptr) int32

+ func Xpthread_key_create(t *TLS, pKey, destructor uintptr) int32

+ func Xpthread_key_delete(t *TLS, key pthread.Pthread_key_t) int32

+ func Xpthread_mutex_destroy(t *TLS, pMutex uintptr) int32

+ func Xpthread_mutex_init(t *TLS, pMutex, pAttr uintptr) int32

+ func Xpthread_mutex_lock(t *TLS, pMutex uintptr) int32

+ func Xpthread_mutex_trylock(t *TLS, pMutex uintptr) int32

+ func Xpthread_mutex_unlock(t *TLS, pMutex uintptr) int32

+ func Xpthread_mutexattr_destroy(tls *TLS, a uintptr) int32 — darwin/amd64, linux/amd64

+ func Xpthread_mutexattr_init(tls *TLS, a uintptr) int32 — darwin/amd64, linux/amd64

+ func Xpthread_mutexattr_settype(tls *TLS, a uintptr, type1 int32) int32 — darwin/amd64, linux/amd64

+ func Xpthread_self(t *TLS) pthread.Pthread_t

+ func Xpthread_setspecific(t *TLS, key pthread.Pthread_key_t, value uintptr) int32

+ func Xputc(t *TLS, c int32, fp uintptr) int32

+ func Xputchar(t *TLS, c int32) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xputenv(tls *TLS, s uintptr) int32 — darwin/amd64, windows/amd64

+ func Xputs(t *TLS, s uintptr) int32

+ func Xpwrite(t *TLS, fd int32, buf uintptr, count types.Size_t, offset types.Off_t) types.Ssize_t — darwin/amd64, linux/amd64

+ func Xqsort(t *TLS, base uintptr, nmemb, size types.Size_t, compar uintptr)

+ func Xraise(t *TLS, sig int32) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xrand(t *TLS) int32

+ func Xrand_r(tls *TLS, seed uintptr) int32 — darwin/amd64, linux/amd64

+ func Xrandom(t *TLS) long

+ func Xrandom_r(t *TLS, buf, result uintptr) int32 — darwin/amd64, linux/amd64

+ func Xread(t *TLS, fd int32, buf uintptr, count types.Size_t) types.Ssize_t — darwin/amd64, linux/amd64

+ func Xread(t *TLS, fd int32, buf uintptr, count uint32) int32 — windows/amd64

+ func Xreaddir(t *TLS, dir uintptr) uintptr — darwin/amd64

+ func Xreaddir(tls *TLS, dir uintptr) uintptr — linux/amd64, windows/amd64

+ func Xreaddir64(t *TLS, dir uintptr) uintptr — linux/amd64

+ func Xreadlink(t *TLS, path, buf uintptr, bufsize types.Size_t) types.Ssize_t — darwin/amd64, linux/amd64, windows/amd64

+ func Xreadlinkat(t *TLS, dirfd int32, pathname, buf uintptr, bufsiz types.Size_t) types.Ssize_t — linux/amd64

+ func Xreadv(t *TLS, fd int32, iov uintptr, iovcnt int32) types.Ssize_t

+ func Xrealloc(t *TLS, ptr uintptr, size types.Size_t) uintptr

+ func Xreallocarray(t *TLS, ptr uintptr, nmemb, size size_t) uintptr

+ func Xrealpath(t *TLS, path, resolved_path uintptr) uintptr — darwin/amd64, linux/amd64, windows/amd64

+ func Xrecv(t *TLS, sockfd int32, buf uintptr, len types.Size_t, flags int32) types.Ssize_t — darwin/amd64, linux/amd64

+ func Xrecv(t *TLS, sockfd uint64, buf uintptr, len, flags int32) int32 — windows/amd64

+ func Xrecvfrom(t *TLS, sockfd int32, buf uintptr, len types.Size_t, flags int32, ...) types.Ssize_t — darwin/amd64, linux/amd64

+ func Xrecvmsg(t *TLS, sockfd int32, msg uintptr, flags int32) types.Ssize_t — darwin/amd64, linux/amd64

+ func Xremove(t *TLS, pathname uintptr) int32 — darwin/amd64, linux/amd64

+ func Xrename(t *TLS, oldpath, newpath uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xrenameat2(t *TLS, olddirfd int32, oldpath uintptr, newdirfd int32, newpath uintptr, ...) int32 — linux/amd64

+ func Xrewind(t *TLS, stream uintptr) — darwin/amd64, linux/amd64, windows/amd64

+ func Xrindex(t *TLS, s uintptr, c int32) uintptr

+ func Xrint(tls *TLS, x float64) float64 — darwin/amd64, linux/amd64, windows/amd64

+ func Xrmdir(t *TLS, pathname uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xround(t *TLS, x float64) float64

+ func Xscalbn(tls *TLS, x float64, n int32) float64 — darwin/amd64, linux/amd64

+ func Xscalbnl(tls *TLS, x float64, n int32) float64 — darwin/amd64, linux/amd64

+ func Xsched_yield(t *TLS)

+ func Xselect(t *TLS, nfds int32, readfds, writefds, exceptfds, timeout uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xsend(t *TLS, sockfd int32, buf uintptr, len types.Size_t, flags int32) types.Ssize_t — darwin/amd64, linux/amd64

+ func Xsend(t *TLS, sockfd uint64, buf uintptr, len, flags int32) int32 — windows/amd64

+ func Xsendmsg(t *TLS, sockfd int32, msg uintptr, flags int32) types.Ssize_t — darwin/amd64, linux/amd64

+ func Xsendto(t *TLS, sockfd int32, buf uintptr, len types.Size_t, flags int32, ...) types.Ssize_t — darwin/amd64, linux/amd64

+ func Xsetattrlist(t *TLS, path, attrList, attrBuf uintptr, attrBufSize types.Size_t, ...) int32 — darwin/amd64

+ func Xsetbuf(t *TLS, stream, buf uintptr)

+ func Xsetenv(t *TLS, name, value uintptr, overwrite int32) int32 — linux/amd64

+ func Xsetenv(tls *TLS, var1 uintptr, value uintptr, overwrite int32) int32 — darwin/amd64, windows/amd64

+ func Xsetjmp(t *TLS, env uintptr) int32

+ func Xsetlocale(t *TLS, category int32, locale uintptr) uintptr — darwin/amd64, linux/amd64, windows/amd64

+ func Xsetmode(t *TLS, fd, mode int32) int32 — windows/amd64

+ func Xsetrlimit(t *TLS, resource int32, rlim uintptr) int32 — linux/amd64, windows/amd64

+ func Xsetrlimit64(t *TLS, resource int32, rlim uintptr) int32 — linux/amd64, windows/amd64

+ func Xsetsid(t *TLS) types.Pid_t

+ func Xsetsockopt(t *TLS, _ ...interface{}) int32 — windows/amd64

+ func Xsetsockopt(t *TLS, sockfd, level, optname int32, optval uintptr, optlen socket.Socklen_t) int32 — darwin/amd64, linux/amd64

+ func Xsetstate(t *TLS, state uintptr) uintptr — darwin/amd64, linux/amd64

+ func Xsetvbuf(t *TLS, stream, buf uintptr, mode int32, size types.Size_t) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xshmat(t *TLS, shmid int32, shmaddr uintptr, shmflg int32) uintptr — darwin/amd64, linux/amd64

+ func Xshmctl(t *TLS, shmid, cmd int32, buf uintptr) int32 — darwin/amd64, linux/amd64

+ func Xshmdt(t *TLS, shmaddr uintptr) int32 — darwin/amd64, linux/amd64

+ func Xshutdown(t *TLS, sockfd uint64, how int32) int32 — windows/amd64

+ func Xshutdown(t *TLS, sockfd, how int32) int32 — darwin/amd64, linux/amd64

+ func Xsigaction(t *TLS, signum int32, act, oldact uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xsignal(t *TLS, signum int32, handler uintptr) uintptr — darwin/amd64, linux/amd64

+ func Xsin(t *TLS, x float64) float64

+ func Xsinf(t *TLS, x float32) float32

+ func Xsinh(t *TLS, x float64) float64

+ func Xsleep(t *TLS, seconds uint32) uint32

+ func Xsnprintf(t *TLS, str uintptr, size types.Size_t, format, args uintptr) (r int32)

+ func Xsocket(t *TLS, domain, type1, protocol int32) int32 — darwin/amd64, linux/amd64

+ func Xsocket(t *TLS, domain, type1, protocol int32) uint64 — windows/amd64

+ func Xsprintf(t *TLS, str, format, args uintptr) (r int32)

+ func Xsqrt(t *TLS, x float64) float64

+ func Xsrand48(t *TLS, seedval long) — darwin/amd64, linux/amd64

+ func Xsrandomdev(t *TLS) — darwin/amd64

+ func Xsscanf(t *TLS, str, format, va uintptr) int32 — darwin/amd64, windows/amd64

+ func Xsscanf(tls *TLS, s uintptr, fmt uintptr, va uintptr) int32 — linux/amd64

+ func Xstat(t *TLS, pathname, statbuf uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xstat64(t *TLS, pathname, statbuf uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xstatfs(t *TLS, path uintptr, buf uintptr) int32 — darwin/amd64

+ func Xstrcasecmp(t *TLS, s1, s2 uintptr) int32

+ func Xstrcat(t *TLS, dest, src uintptr) (r uintptr)

+ func Xstrchr(t *TLS, s uintptr, c int32) uintptr

+ func Xstrcmp(t *TLS, s1, s2 uintptr) int32

+ func Xstrcpy(t *TLS, dest, src uintptr) (r uintptr)

+ func Xstrcspn(t *TLS, s, reject uintptr) (r types.Size_t)

+ func Xstrdup(tls *TLS, s uintptr) uintptr — darwin/amd64, linux/amd64, windows/amd64

+ func Xstrerror(t *TLS, errnum int32) uintptr — darwin/amd64, linux/amd64, windows/amd64

+ func Xstrerror_r(t *TLS, errnum int32, buf uintptr, buflen size_t) int32 — darwin/amd64, linux/amd64

+ func Xstrlcat(tls *TLS, d uintptr, s uintptr, n size_t) size_t — darwin/amd64, linux/amd64

+ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n size_t) size_t — darwin/amd64, linux/amd64

+ func Xstrlen(t *TLS, s uintptr) (r types.Size_t)

+ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n size_t) int32 — darwin/amd64, linux/amd64

+ func Xstrncat(tls *TLS, d uintptr, s uintptr, n size_t) uintptr — darwin/amd64, linux/amd64

+ func Xstrncmp(t *TLS, s1, s2 uintptr, n types.Size_t) int32

+ func Xstrncpy(t *TLS, dest, src uintptr, n types.Size_t) (r uintptr)

+ func Xstrnlen(tls *TLS, s uintptr, n size_t) size_t — darwin/amd64, linux/amd64

+ func Xstrpbrk(t *TLS, s, accept uintptr) uintptr

+ func Xstrrchr(t *TLS, s uintptr, c int32) (r uintptr)

+ func Xstrspn(tls *TLS, s uintptr, c uintptr) size_t — darwin/amd64, linux/amd64

+ func Xstrstr(t *TLS, haystack, needle uintptr) uintptr

+ func Xstrtod(tls *TLS, s uintptr, p uintptr) float64 — darwin/amd64, linux/amd64, windows/amd64

+ func Xstrtof(tls *TLS, s uintptr, p uintptr) float32 — darwin/amd64, linux/amd64

+ func Xstrtoimax(tls *TLS, s uintptr, p uintptr, base int32) intmax_t — darwin/amd64, linux/amd64

+ func Xstrtok(tls *TLS, s uintptr, sep uintptr) uintptr — darwin/amd64, linux/amd64

+ func Xstrtol(t *TLS, nptr, endptr uintptr, base int32) long — windows/amd64

+ func Xstrtol(tls *TLS, s uintptr, p uintptr, base int32) int64 — darwin/amd64, linux/amd64

+ func Xstrtold(tls *TLS, s uintptr, p uintptr) float64 — darwin/amd64, linux/amd64

+ func Xstrtoll(tls *TLS, s uintptr, p uintptr, base int32) int64 — darwin/amd64, linux/amd64

+ func Xstrtoul(t *TLS, nptr, endptr uintptr, base int32) ulong — windows/amd64

+ func Xstrtoul(tls *TLS, s uintptr, p uintptr, base int32) uint64 — darwin/amd64, linux/amd64

+ func Xstrtoull(tls *TLS, s uintptr, p uintptr, base int32) uint64 — darwin/amd64, linux/amd64

+ func Xstrtoumax(tls *TLS, s uintptr, p uintptr, base int32) uintmax_t — darwin/amd64, linux/amd64

+ func Xsymlink(t *TLS, target, linkpath uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xsymlinkat(t *TLS, target uintptr, newdirfd int32, linkpath uintptr) int32 — linux/amd64

+ func Xsysconf(t *TLS, name int32) long — darwin/amd64, linux/amd64, windows/amd64

+ func Xsystem(t *TLS, command uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xtan(t *TLS, x float64) float64

+ func Xtanh(t *TLS, x float64) float64

+ func Xtcgetattr(t *TLS, fd int32, termios_p uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xtcsendbreak(t *TLS, fd, duration int32) int32

+ func Xtcsetattr(t *TLS, fd, optional_actions int32, termios_p uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xtime(t *TLS, tloc uintptr) types.Time_t — darwin/amd64, linux/amd64, windows/amd64

+ func Xtmpfile(t *TLS) uintptr — darwin/amd64, linux/amd64

+ func Xtoascii(tls *TLS, _c int32) int32 — darwin/amd64

+ func Xtolower(t *TLS, c int32) int32

+ func Xtoupper(t *TLS, c int32) int32

+ func Xtrunc(t *TLS, x float64) float64

+ func Xtruncate(...interface{}) int32 — darwin/amd64

+ func Xtzset(t *TLS) — darwin/amd64, linux/amd64, windows/amd64

+ func Xumask(t *TLS, mask types.Mode_t) types.Mode_t — darwin/amd64, linux/amd64, windows/amd64

+ func Xuname(t *TLS, buf uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xungetc(t *TLS, c int32, stream uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xunlink(t *TLS, pathname uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xunlinkat(t *TLS, dirfd int32, pathname uintptr, flags int32) int32 — linux/amd64

+ func Xunsetenv(t *TLS, name uintptr) int32 — linux/amd64

+ func Xunsetenv(tls *TLS, name uintptr) int32 — darwin/amd64, windows/amd64

+ func Xusleep(t *TLS, usec types.Useconds_t) int32 — darwin/amd64, windows/amd64

+ func Xusleep(t *TLS, usec types.X__useconds_t) int32 — linux/amd64

+ func Xutime(t *TLS, filename, times uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xutimensat(t *TLS, dirfd int32, pathname, times uintptr, flags int32) int32 — linux/amd64

+ func Xutimes(t *TLS, filename, times uintptr) int32 — darwin/amd64, linux/amd64, windows/amd64

+ func Xuuid_copy(t *TLS, dst, src uintptr) — darwin/amd64, linux/amd64

+ func Xuuid_generate_random(t *TLS, out uintptr) — darwin/amd64, linux/amd64

+ func Xuuid_parse(t *TLS, in uintptr, uu uintptr) int32 — darwin/amd64, linux/amd64

+ func Xuuid_unparse(t *TLS, uu, out uintptr) — darwin/amd64, linux/amd64

+ func Xvasprintf(t *TLS, strp, fmt, ap uintptr) int32

+ func Xvfprintf(t *TLS, stream, format, ap uintptr) int32

+ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap va_list) int32 — linux/amd64

+ func Xvprintf(t *TLS, s, ap uintptr) int32

+ func Xvsnprintf(t *TLS, str uintptr, size types.Size_t, format, va uintptr) int32

+ func Xvsprintf(t *TLS, str, format, va uintptr) int32

+ func Xvsscanf(tls *TLS, s uintptr, fmt uintptr, ap va_list) int32 — linux/amd64

+ func Xwaitpid(t *TLS, pid types.Pid_t, wstatus uintptr, optname int32) types.Pid_t — darwin/amd64, linux/amd64, windows/amd64

+ func Xwcrtomb(tls *TLS, s uintptr, wc wchar_t, st uintptr) size_t — windows/amd64

+ func Xwcschr(t *TLS, str uintptr, c wchar_t) uintptr — windows/amd64

+ func Xwcschr(t *TLS, wcs uintptr, wc wchar_t) wchar_t — darwin/amd64, linux/amd64

+ func Xwcscmp(t *TLS, string1, string2 uintptr) int32 — windows/amd64

+ func Xwcscpy(t *TLS, strDestination, strSource uintptr) uintptr — windows/amd64

+ func Xwcsicmp(t *TLS, string1, string2 uintptr) int32 — windows/amd64

+ func Xwcslen(t *TLS, str uintptr) types.Size_t — windows/amd64

+ func Xwcsncmp(t *TLS, string1, string2 uintptr, count types.Size_t) int32 — windows/amd64

+ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n size_t, st uintptr) size_t — windows/amd64

+ func Xwcstombs(tls *TLS, s uintptr, ws uintptr, n size_t) size_t — windows/amd64

+ func Xwctomb(t *TLS, s uintptr, wc wchar_t) int32

+ func Xwcwidth(t *TLS, c wchar_t) int32

+ func Xwrite(t *TLS, fd int32, buf uintptr, count types.Size_t) types.Ssize_t — darwin/amd64, linux/amd64

+ func Xwrite(t *TLS, fd int32, buf uintptr, count uint32) int32 — windows/amd64

+ func Xwritev(t *TLS, fd int32, iov uintptr, iovcnt int32) types.Ssize_t — darwin/amd64, linux/amd64

+ func XwsprintfA(t *TLS, buf, format, args uintptr) int32 — windows/amd64

+ func XwsprintfW(t *TLS, _ ...interface{}) int32 — windows/amd64

+ type DIR = __dirstream — linux/amd64

+ type FILE = _IO_FILE — darwin/amd64, linux/amd64

+ type HEADER = struct — darwin/amd64

+ F__ccgo_pad1 [0]uint32

+ Fid uint32

+ Fnscount uint32

+ Fqdcount uint32

+ type HEADER = struct — linux/amd64

+ type Int128 mathutil.Int128

+ func Int128FromFloat32(n float32) Int128

+ func Int128FromFloat64(n float64) Int128

+ func Int128FromInt16(n int16) Int128

+ func Int128FromInt32(n int32) Int128

+ func Int128FromInt64(n int64) Int128

+ func Int128FromInt8(n int8) Int128

+ func Int128FromUint128(n Uint128) Int128

+ func Int128FromUint16(n uint16) Int128

+ func Int128FromUint32(n uint32) Int128

+ func Int128FromUint64(n uint64) Int128

+ func Int128FromUint8(n uint8) Int128

+ func (n *Int128) LValueDec()

+ func (n *Int128) LValueInc()

+ func (n *Int128) LValueShl(c int32)

+ func (n *Int128) LValueShr(c int32)

+ func (n Int128) Add(m Int128) (r Int128)

+ func (n Int128) And(v Int128) Int128

+ func (n Int128) Cmp(y Int128) int

+ func (n Int128) Float32() float32

+ func (n Int128) Float64() float64

+ func (n Int128) Int16() int16

+ func (n Int128) Int32() int32

+ func (n Int128) Int64() int64

+ func (n Int128) Int8() int8

+ func (n Int128) Mul(m Int128) Int128

+ func (n Int128) Neg() Int128

+ func (n Int128) Or(v Int128) Int128

+ func (n Int128) Shl(c int32) (r Int128)

+ func (n Int128) Shr(c int32) (r Int128)

+ func (n Int128) Uint128() (r Uint128)

+ func (n Int128) Uint16() uint16

+ func (n Int128) Uint32() uint32

+ func (n Int128) Uint64() uint64

+ func (n Int128) Uint8() uint8

+ func (n Int128) Xor(v Int128) Int128

+ type PerfCounter struct

+ func NewPerfCounter(labels []string) *PerfCounter

+ func (c *PerfCounter) Clear()

+ func (c *PerfCounter) Disable()

+ func (c *PerfCounter) Enable()

+ func (c *PerfCounter) Inc(n int)

+ func (c *PerfCounter) IncN(n, m int)

+ func (c *PerfCounter) String() string

+ type RawMem [1<<50 - 1]byte — darwin/amd64, linux/amd64, windows/amd64

+ type RawMem64 [unsafe.Sizeof(RawMem{}) / unsafe.Sizeof(uint64(0))]uint64

+ type StackCapture struct

+ func NewStackCapture(depth int) *StackCapture

+ func (c *StackCapture) Clear()

+ func (c *StackCapture) Disable()

+ func (c *StackCapture) Enable()

+ func (c *StackCapture) Record()

+ func (c *StackCapture) String() string

+ type TLS struct

+ ID int32

+ func NewTLS() *TLS

+ func (t *TLS) Alloc(n int) (r uintptr)

+ func (t *TLS) Close()

+ func (t *TLS) Free(n int)

+ type ThreadAdapter struct — windows/amd64

+ type Uint128 mathutil.Uint128

+ func Uint128FromFloat32(n float32) Uint128

+ func Uint128FromFloat64(n float64) Uint128

+ func Uint128FromInt128(n Int128) Uint128

+ func Uint128FromInt16(n int16) Uint128

+ func Uint128FromInt32(n int32) Uint128

+ func Uint128FromInt64(n int64) (r Uint128)

+ func Uint128FromInt8(n int8) Uint128

+ func Uint128FromUint16(n uint16) Uint128

+ func Uint128FromUint32(n uint32) Uint128

+ func Uint128FromUint64(n uint64) Uint128

+ func Uint128FromUint8(n uint8) Uint128

+ func (n *Uint128) LValueShl(c int32)

+ func (n *Uint128) LValueShr(c int32)

+ func (n Uint128) Add(m Uint128) (r Uint128)

+ func (n Uint128) And(m Uint128) Uint128

+ func (n Uint128) Cmp(m Uint128) int

+ func (n Uint128) Div(m Uint128) (r Uint128)

+ func (n Uint128) Float32() float32

+ func (n Uint128) Float64() float64

+ func (n Uint128) Int128() Int128

+ func (n Uint128) Int16() int16

+ func (n Uint128) Int32() int32

+ func (n Uint128) Int64() int64

+ func (n Uint128) Int8() int8

+ func (n Uint128) Mul(m Uint128) Uint128

+ func (n Uint128) Or(m Uint128) Uint128

+ func (n Uint128) Shl(c int32) (r Uint128)

+ func (n Uint128) Shr(c int32) (r Uint128)

+ func (n Uint128) Sub(m Uint128) Uint128

+ func (n Uint128) Uint16() uint16

+ func (n Uint128) Uint32() uint32

+ func (n Uint128) Uint64() uint64

+ func (n Uint128) Uint8() uint8

+ func (n Uint128) Xor(m Uint128) Uint128

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL