README

libc

Package libc provides C-runtime services. Work in progress.

This package is a continuation of the Crt package in modernc.org/crt/v3.

Installation

$ go get [-u] modernc.org/libc

Documentation: godoc.org/modernc.org/libc

Building with make requires the following Go packages

  • github.com/golang/lint/golint
  • github.com/mdempsky/maligned
  • github.com/mdempsky/unconvert
  • honnef.co/go/tools/cmd/unused
  • honnef.co/go/tools/cmd/gosimple
  • github.com/client9/misspell/cmd/misspell

Documentation

Overview

    Package libc provides run time support for ccgo generated programs and implements selected parts of the C standard library.

    Some functions are implemented only when CGO_ENABLED=1 and panic otherwise.

    Index

    Constants

    This section is empty.

    Variables

    View Source
    var CAPI = map[string]struct{}{}/* 249 elements not displayed */
    
    View Source
    var (
    	Covered = map[uintptr]struct{}{}
    )
    View Source
    var Xstderr uintptr

      Keep these outside of the var block otherwise go generate will miss them.

      View Source
      var Xstdin uintptr
      View Source
      var Xstdout uintptr

      Functions

      func AssignAddFloat32

      func AssignAddFloat32(p *float32, v float32) float32

      func AssignAddFloat64

      func AssignAddFloat64(p *float64, v float64) float64

      func AssignAddInt16

      func AssignAddInt16(p *int16, v int16) int16

      func AssignAddInt32

      func AssignAddInt32(p *int32, v int32) int32

      func AssignAddInt64

      func AssignAddInt64(p *int64, v int64) int64

      func AssignAddInt8

      func AssignAddInt8(p *int8, v int8) int8

      func AssignAddPtrFloat32

      func AssignAddPtrFloat32(p uintptr, v float32) float32

      func AssignAddPtrFloat64

      func AssignAddPtrFloat64(p uintptr, v float64) float64

      func AssignAddPtrInt16

      func AssignAddPtrInt16(p uintptr, v int16) int16

      func AssignAddPtrInt32

      func AssignAddPtrInt32(p uintptr, v int32) int32

      func AssignAddPtrInt64

      func AssignAddPtrInt64(p uintptr, v int64) int64

      func AssignAddPtrInt8

      func AssignAddPtrInt8(p uintptr, v int8) int8

      func AssignAddPtrUint16

      func AssignAddPtrUint16(p uintptr, v uint16) uint16

      func AssignAddPtrUint32

      func AssignAddPtrUint32(p uintptr, v uint32) uint32

      func AssignAddPtrUint64

      func AssignAddPtrUint64(p uintptr, v uint64) uint64

      func AssignAddPtrUint8

      func AssignAddPtrUint8(p uintptr, v uint8) uint8

      func AssignAddPtrUintptr

      func AssignAddPtrUintptr(p uintptr, v uintptr) uintptr

      func AssignAddUint16

      func AssignAddUint16(p *uint16, v uint16) uint16

      func AssignAddUint32

      func AssignAddUint32(p *uint32, v uint32) uint32

      func AssignAddUint64

      func AssignAddUint64(p *uint64, v uint64) uint64

      func AssignAddUint8

      func AssignAddUint8(p *uint8, v uint8) uint8

      func AssignAddUintptr

      func AssignAddUintptr(p *uintptr, v uintptr) uintptr

      func AssignAndInt16

      func AssignAndInt16(p *int16, v int16) int16

      func AssignAndInt32

      func AssignAndInt32(p *int32, v int32) int32

      func AssignAndInt64

      func AssignAndInt64(p *int64, v int64) int64

      func AssignAndInt8

      func AssignAndInt8(p *int8, v int8) int8

      func AssignAndPtrInt16

      func AssignAndPtrInt16(p uintptr, v int16) int16

      func AssignAndPtrInt32

      func AssignAndPtrInt32(p uintptr, v int32) int32

      func AssignAndPtrInt64

      func AssignAndPtrInt64(p uintptr, v int64) int64

      func AssignAndPtrInt8

      func AssignAndPtrInt8(p uintptr, v int8) int8

      func AssignAndPtrUint16

      func AssignAndPtrUint16(p uintptr, v uint16) uint16

      func AssignAndPtrUint32

      func AssignAndPtrUint32(p uintptr, v uint32) uint32

      func AssignAndPtrUint64

      func AssignAndPtrUint64(p uintptr, v uint64) uint64

      func AssignAndPtrUint8

      func AssignAndPtrUint8(p uintptr, v uint8) uint8

      func AssignAndPtrUintptr

      func AssignAndPtrUintptr(p uintptr, v uintptr) uintptr

      func AssignAndUint16

      func AssignAndUint16(p *uint16, v uint16) uint16

      func AssignAndUint32

      func AssignAndUint32(p *uint32, v uint32) uint32

      func AssignAndUint64

      func AssignAndUint64(p *uint64, v uint64) uint64

      func AssignAndUint8

      func AssignAndUint8(p *uint8, v uint8) uint8

      func AssignAndUintptr

      func AssignAndUintptr(p *uintptr, v uintptr) uintptr

      func AssignBitFieldPtr16Int16

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

      func AssignBitFieldPtr16Int32

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

      func AssignBitFieldPtr16Int64

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

      func AssignBitFieldPtr16Int8

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

      func AssignBitFieldPtr16Uint16

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

      func AssignBitFieldPtr16Uint32

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

      func AssignBitFieldPtr16Uint64

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

      func AssignBitFieldPtr16Uint8

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

      func AssignBitFieldPtr32Int16

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

      func AssignBitFieldPtr32Int32

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

      func AssignBitFieldPtr32Int64

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

      func AssignBitFieldPtr32Int8

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

      func AssignBitFieldPtr32Uint16

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

      func AssignBitFieldPtr32Uint32

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

      func AssignBitFieldPtr32Uint64

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

      func AssignBitFieldPtr32Uint8

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

      func AssignBitFieldPtr64Int16

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

      func AssignBitFieldPtr64Int32

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

      func AssignBitFieldPtr64Int64

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

      func AssignBitFieldPtr64Int8

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

      func AssignBitFieldPtr64Uint16

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

      func AssignBitFieldPtr64Uint32

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

      func AssignBitFieldPtr64Uint64

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

      func AssignBitFieldPtr64Uint8

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

      func AssignBitFieldPtr8Int16

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

      func AssignBitFieldPtr8Int32

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

      func AssignBitFieldPtr8Int64

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

      func AssignBitFieldPtr8Int8

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

      func AssignBitFieldPtr8Uint16

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

      func AssignBitFieldPtr8Uint32

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

      func AssignBitFieldPtr8Uint64

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

      func AssignBitFieldPtr8Uint8

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

      func AssignDivFloat32

      func AssignDivFloat32(p *float32, v float32) float32

      func AssignDivFloat64

      func AssignDivFloat64(p *float64, v float64) float64

      func AssignDivInt16

      func AssignDivInt16(p *int16, v int16) int16

      func AssignDivInt32

      func AssignDivInt32(p *int32, v int32) int32

      func AssignDivInt64

      func AssignDivInt64(p *int64, v int64) int64

      func AssignDivInt8

      func AssignDivInt8(p *int8, v int8) int8

      func AssignDivPtrFloat32

      func AssignDivPtrFloat32(p uintptr, v float32) float32

      func AssignDivPtrFloat64

      func AssignDivPtrFloat64(p uintptr, v float64) float64

      func AssignDivPtrInt16

      func AssignDivPtrInt16(p uintptr, v int16) int16

      func AssignDivPtrInt32

      func AssignDivPtrInt32(p uintptr, v int32) int32

      func AssignDivPtrInt64

      func AssignDivPtrInt64(p uintptr, v int64) int64

      func AssignDivPtrInt8

      func AssignDivPtrInt8(p uintptr, v int8) int8

      func AssignDivPtrUint16

      func AssignDivPtrUint16(p uintptr, v uint16) uint16

      func AssignDivPtrUint32

      func AssignDivPtrUint32(p uintptr, v uint32) uint32

      func AssignDivPtrUint64

      func AssignDivPtrUint64(p uintptr, v uint64) uint64

      func AssignDivPtrUint8

      func AssignDivPtrUint8(p uintptr, v uint8) uint8

      func AssignDivPtrUintptr

      func AssignDivPtrUintptr(p uintptr, v uintptr) uintptr

      func AssignDivUint16

      func AssignDivUint16(p *uint16, v uint16) uint16

      func AssignDivUint32

      func AssignDivUint32(p *uint32, v uint32) uint32

      func AssignDivUint64

      func AssignDivUint64(p *uint64, v uint64) uint64

      func AssignDivUint8

      func AssignDivUint8(p *uint8, v uint8) uint8

      func AssignDivUintptr

      func AssignDivUintptr(p *uintptr, v uintptr) uintptr

      func AssignFloat32

      func AssignFloat32(p *float32, v float32) float32

      func AssignFloat64

      func AssignFloat64(p *float64, v float64) float64

      func AssignInt16

      func AssignInt16(p *int16, v int16) int16

      func AssignInt32

      func AssignInt32(p *int32, v int32) int32

      func AssignInt64

      func AssignInt64(p *int64, v int64) int64

      func AssignInt8

      func AssignInt8(p *int8, v int8) int8

      func AssignMulFloat32

      func AssignMulFloat32(p *float32, v float32) float32

      func AssignMulFloat64

      func AssignMulFloat64(p *float64, v float64) float64

      func AssignMulInt16

      func AssignMulInt16(p *int16, v int16) int16

      func AssignMulInt32

      func AssignMulInt32(p *int32, v int32) int32

      func AssignMulInt64

      func AssignMulInt64(p *int64, v int64) int64

      func AssignMulInt8

      func AssignMulInt8(p *int8, v int8) int8

      func AssignMulPtrFloat32

      func AssignMulPtrFloat32(p uintptr, v float32) float32

      func AssignMulPtrFloat64

      func AssignMulPtrFloat64(p uintptr, v float64) float64

      func AssignMulPtrInt16

      func AssignMulPtrInt16(p uintptr, v int16) int16

      func AssignMulPtrInt32

      func AssignMulPtrInt32(p uintptr, v int32) int32

      func AssignMulPtrInt64

      func AssignMulPtrInt64(p uintptr, v int64) int64

      func AssignMulPtrInt8

      func AssignMulPtrInt8(p uintptr, v int8) int8

      func AssignMulPtrUint16

      func AssignMulPtrUint16(p uintptr, v uint16) uint16

      func AssignMulPtrUint32

      func AssignMulPtrUint32(p uintptr, v uint32) uint32

      func AssignMulPtrUint64

      func AssignMulPtrUint64(p uintptr, v uint64) uint64

      func AssignMulPtrUint8

      func AssignMulPtrUint8(p uintptr, v uint8) uint8

      func AssignMulPtrUintptr

      func AssignMulPtrUintptr(p uintptr, v uintptr) uintptr

      func AssignMulUint16

      func AssignMulUint16(p *uint16, v uint16) uint16

      func AssignMulUint32

      func AssignMulUint32(p *uint32, v uint32) uint32

      func AssignMulUint64

      func AssignMulUint64(p *uint64, v uint64) uint64

      func AssignMulUint8

      func AssignMulUint8(p *uint8, v uint8) uint8

      func AssignMulUintptr

      func AssignMulUintptr(p *uintptr, v uintptr) uintptr

      func AssignOrInt16

      func AssignOrInt16(p *int16, v int16) int16

      func AssignOrInt32

      func AssignOrInt32(p *int32, v int32) int32

      func AssignOrInt64

      func AssignOrInt64(p *int64, v int64) int64

      func AssignOrInt8

      func AssignOrInt8(p *int8, v int8) int8

      func AssignOrPtrInt16

      func AssignOrPtrInt16(p uintptr, v int16) int16

      func AssignOrPtrInt32

      func AssignOrPtrInt32(p uintptr, v int32) int32

      func AssignOrPtrInt64

      func AssignOrPtrInt64(p uintptr, v int64) int64

      func AssignOrPtrInt8

      func AssignOrPtrInt8(p uintptr, v int8) int8

      func AssignOrPtrUint16

      func AssignOrPtrUint16(p uintptr, v uint16) uint16

      func AssignOrPtrUint32

      func AssignOrPtrUint32(p uintptr, v uint32) uint32

      func AssignOrPtrUint64

      func AssignOrPtrUint64(p uintptr, v uint64) uint64

      func AssignOrPtrUint8

      func AssignOrPtrUint8(p uintptr, v uint8) uint8

      func AssignOrPtrUintptr

      func AssignOrPtrUintptr(p uintptr, v uintptr) uintptr

      func AssignOrUint16

      func AssignOrUint16(p *uint16, v uint16) uint16

      func AssignOrUint32

      func AssignOrUint32(p *uint32, v uint32) uint32

      func AssignOrUint64

      func AssignOrUint64(p *uint64, v uint64) uint64

      func AssignOrUint8

      func AssignOrUint8(p *uint8, v uint8) uint8

      func AssignOrUintptr

      func AssignOrUintptr(p *uintptr, v uintptr) uintptr

      func AssignPtrFloat32

      func AssignPtrFloat32(p uintptr, v float32) float32

      func AssignPtrFloat64

      func AssignPtrFloat64(p uintptr, v float64) float64

      func AssignPtrInt16

      func AssignPtrInt16(p uintptr, v int16) int16

      func AssignPtrInt32

      func AssignPtrInt32(p uintptr, v int32) int32

      func AssignPtrInt64

      func AssignPtrInt64(p uintptr, v int64) int64

      func AssignPtrInt8

      func AssignPtrInt8(p uintptr, v int8) int8

      func AssignPtrUint16

      func AssignPtrUint16(p uintptr, v uint16) uint16

      func AssignPtrUint32

      func AssignPtrUint32(p uintptr, v uint32) uint32

      func AssignPtrUint64

      func AssignPtrUint64(p uintptr, v uint64) uint64

      func AssignPtrUint8

      func AssignPtrUint8(p uintptr, v uint8) uint8

      func AssignPtrUintptr

      func AssignPtrUintptr(p uintptr, v uintptr) uintptr

      func AssignRemInt16

      func AssignRemInt16(p *int16, v int16) int16

      func AssignRemInt32

      func AssignRemInt32(p *int32, v int32) int32

      func AssignRemInt64

      func AssignRemInt64(p *int64, v int64) int64

      func AssignRemInt8

      func AssignRemInt8(p *int8, v int8) int8

      func AssignRemPtrInt16

      func AssignRemPtrInt16(p uintptr, v int16) int16

      func AssignRemPtrInt32

      func AssignRemPtrInt32(p uintptr, v int32) int32

      func AssignRemPtrInt64

      func AssignRemPtrInt64(p uintptr, v int64) int64

      func AssignRemPtrInt8

      func AssignRemPtrInt8(p uintptr, v int8) int8

      func AssignRemPtrUint16

      func AssignRemPtrUint16(p uintptr, v uint16) uint16

      func AssignRemPtrUint32

      func AssignRemPtrUint32(p uintptr, v uint32) uint32

      func AssignRemPtrUint64

      func AssignRemPtrUint64(p uintptr, v uint64) uint64

      func AssignRemPtrUint8

      func AssignRemPtrUint8(p uintptr, v uint8) uint8

      func AssignRemPtrUintptr

      func AssignRemPtrUintptr(p uintptr, v uintptr) uintptr

      func AssignRemUint16

      func AssignRemUint16(p *uint16, v uint16) uint16

      func AssignRemUint32

      func AssignRemUint32(p *uint32, v uint32) uint32

      func AssignRemUint64

      func AssignRemUint64(p *uint64, v uint64) uint64

      func AssignRemUint8

      func AssignRemUint8(p *uint8, v uint8) uint8

      func AssignRemUintptr

      func AssignRemUintptr(p *uintptr, v uintptr) uintptr

      func AssignShlInt16

      func AssignShlInt16(p *int16, v int) int16

      func AssignShlInt32

      func AssignShlInt32(p *int32, v int) int32

      func AssignShlInt64

      func AssignShlInt64(p *int64, v int) int64

      func AssignShlInt8

      func AssignShlInt8(p *int8, v int) int8

      func AssignShlPtrInt16

      func AssignShlPtrInt16(p uintptr, v int) int16

      func AssignShlPtrInt32

      func AssignShlPtrInt32(p uintptr, v int) int32

      func AssignShlPtrInt64

      func AssignShlPtrInt64(p uintptr, v int) int64

      func AssignShlPtrInt8

      func AssignShlPtrInt8(p uintptr, v int) int8

      func AssignShlPtrUint16

      func AssignShlPtrUint16(p uintptr, v int) uint16

      func AssignShlPtrUint32

      func AssignShlPtrUint32(p uintptr, v int) uint32

      func AssignShlPtrUint64

      func AssignShlPtrUint64(p uintptr, v int) uint64

      func AssignShlPtrUint8

      func AssignShlPtrUint8(p uintptr, v int) uint8

      func AssignShlPtrUintptr

      func AssignShlPtrUintptr(p uintptr, v int) uintptr

      func AssignShlUint16

      func AssignShlUint16(p *uint16, v int) uint16

      func AssignShlUint32

      func AssignShlUint32(p *uint32, v int) uint32

      func AssignShlUint64

      func AssignShlUint64(p *uint64, v int) uint64

      func AssignShlUint8

      func AssignShlUint8(p *uint8, v int) uint8

      func AssignShlUintptr

      func AssignShlUintptr(p *uintptr, v int) uintptr

      func AssignShrInt16

      func AssignShrInt16(p *int16, v int) int16

      func AssignShrInt32

      func AssignShrInt32(p *int32, v int) int32

      func AssignShrInt64

      func AssignShrInt64(p *int64, v int) int64

      func AssignShrInt8

      func AssignShrInt8(p *int8, v int) int8

      func AssignShrPtrInt16

      func AssignShrPtrInt16(p uintptr, v int) int16

      func AssignShrPtrInt32

      func AssignShrPtrInt32(p uintptr, v int) int32

      func AssignShrPtrInt64

      func AssignShrPtrInt64(p uintptr, v int) int64

      func AssignShrPtrInt8

      func AssignShrPtrInt8(p uintptr, v int) int8

      func AssignShrPtrUint16

      func AssignShrPtrUint16(p uintptr, v int) uint16

      func AssignShrPtrUint32

      func AssignShrPtrUint32(p uintptr, v int) uint32

      func AssignShrPtrUint64

      func AssignShrPtrUint64(p uintptr, v int) uint64

      func AssignShrPtrUint8

      func AssignShrPtrUint8(p uintptr, v int) uint8

      func AssignShrPtrUintptr

      func AssignShrPtrUintptr(p uintptr, v int) uintptr

      func AssignShrUint16

      func AssignShrUint16(p *uint16, v int) uint16

      func AssignShrUint32

      func AssignShrUint32(p *uint32, v int) uint32

      func AssignShrUint64

      func AssignShrUint64(p *uint64, v int) uint64

      func AssignShrUint8

      func AssignShrUint8(p *uint8, v int) uint8

      func AssignShrUintptr

      func AssignShrUintptr(p *uintptr, v int) uintptr

      func AssignSubFloat32

      func AssignSubFloat32(p *float32, v float32) float32

      func AssignSubFloat64

      func AssignSubFloat64(p *float64, v float64) float64

      func AssignSubInt16

      func AssignSubInt16(p *int16, v int16) int16

      func AssignSubInt32

      func AssignSubInt32(p *int32, v int32) int32

      func AssignSubInt64

      func AssignSubInt64(p *int64, v int64) int64

      func AssignSubInt8

      func AssignSubInt8(p *int8, v int8) int8

      func AssignSubPtrFloat32

      func AssignSubPtrFloat32(p uintptr, v float32) float32

      func AssignSubPtrFloat64

      func AssignSubPtrFloat64(p uintptr, v float64) float64

      func AssignSubPtrInt16

      func AssignSubPtrInt16(p uintptr, v int16) int16

      func AssignSubPtrInt32

      func AssignSubPtrInt32(p uintptr, v int32) int32

      func AssignSubPtrInt64

      func AssignSubPtrInt64(p uintptr, v int64) int64

      func AssignSubPtrInt8

      func AssignSubPtrInt8(p uintptr, v int8) int8

      func AssignSubPtrUint16

      func AssignSubPtrUint16(p uintptr, v uint16) uint16

      func AssignSubPtrUint32

      func AssignSubPtrUint32(p uintptr, v uint32) uint32

      func AssignSubPtrUint64

      func AssignSubPtrUint64(p uintptr, v uint64) uint64

      func AssignSubPtrUint8

      func AssignSubPtrUint8(p uintptr, v uint8) uint8

      func AssignSubPtrUintptr

      func AssignSubPtrUintptr(p uintptr, v uintptr) uintptr

      func AssignSubUint16

      func AssignSubUint16(p *uint16, v uint16) uint16

      func AssignSubUint32

      func AssignSubUint32(p *uint32, v uint32) uint32

      func AssignSubUint64

      func AssignSubUint64(p *uint64, v uint64) uint64

      func AssignSubUint8

      func AssignSubUint8(p *uint8, v uint8) uint8

      func AssignSubUintptr

      func AssignSubUintptr(p *uintptr, v uintptr) uintptr

      func AssignUint16

      func AssignUint16(p *uint16, v uint16) uint16

      func AssignUint32

      func AssignUint32(p *uint32, v uint32) uint32

      func AssignUint64

      func AssignUint64(p *uint64, v uint64) uint64

      func AssignUint8

      func AssignUint8(p *uint8, v uint8) uint8

      func AssignUintptr

      func AssignUintptr(p *uintptr, v uintptr) uintptr

      func AssignXorInt16

      func AssignXorInt16(p *int16, v int16) int16

      func AssignXorInt32

      func AssignXorInt32(p *int32, v int32) int32

      func AssignXorInt64

      func AssignXorInt64(p *int64, v int64) int64

      func AssignXorInt8

      func AssignXorInt8(p *int8, v int8) int8

      func AssignXorPtrInt16

      func AssignXorPtrInt16(p uintptr, v int16) int16

      func AssignXorPtrInt32

      func AssignXorPtrInt32(p uintptr, v int32) int32

      func AssignXorPtrInt64

      func AssignXorPtrInt64(p uintptr, v int64) int64

      func AssignXorPtrInt8

      func AssignXorPtrInt8(p uintptr, v int8) int8

      func AssignXorPtrUint16

      func AssignXorPtrUint16(p uintptr, v uint16) uint16

      func AssignXorPtrUint32

      func AssignXorPtrUint32(p uintptr, v uint32) uint32

      func AssignXorPtrUint64

      func AssignXorPtrUint64(p uintptr, v uint64) uint64

      func AssignXorPtrUint8

      func AssignXorPtrUint8(p uintptr, v uint8) uint8

      func AssignXorPtrUintptr

      func AssignXorPtrUintptr(p uintptr, v uintptr) uintptr

      func AssignXorUint16

      func AssignXorUint16(p *uint16, v uint16) uint16

      func AssignXorUint32

      func AssignXorUint32(p *uint32, v uint32) uint32

      func AssignXorUint64

      func AssignXorUint64(p *uint64, v uint64) uint64

      func AssignXorUint8

      func AssignXorUint8(p *uint8, v uint8) uint8

      func AssignXorUintptr

      func AssignXorUintptr(p *uintptr, v uintptr) uintptr

      func Bool32

      func Bool32(b bool) int32

      func Bool64

      func Bool64(b bool) int64

      func BoolInt16

      func BoolInt16(b bool) int16

      func BoolInt32

      func BoolInt32(b bool) int32

      func BoolInt64

      func BoolInt64(b bool) int64

      func BoolInt8

      func BoolInt8(b bool) int8

      func BoolUint16

      func BoolUint16(b bool) uint16

      func BoolUint32

      func BoolUint32(b bool) uint32

      func BoolUint64

      func BoolUint64(b bool) uint64

      func BoolUint8

      func BoolUint8(b bool) uint8

      func CString

      func CString(s string) (uintptr, error)

      func Cover

      func Cover()

      func CoverReport

      func CoverReport(w io.Writer) error

      func CplInt16

      func CplInt16(n int16) int16

      func CplInt32

      func CplInt32(n int32) int32

      func CplInt64

      func CplInt64(n int64) int64

      func CplInt8

      func CplInt8(n int8) int8

      func CplUint16

      func CplUint16(n uint16) uint16

      func CplUint32

      func CplUint32(n uint32) uint32

      func CplUint64

      func CplUint64(n uint64) uint64

      func CplUint8

      func CplUint8(n uint8) uint8

      func CplUintptr

      func CplUintptr(n uintptr) uintptr

      func Environ

      func Environ() uintptr

      func EnvironP

      func EnvironP() uintptr

      func Float32

      func Float32(n float32) float32

      func Float32FromFloat32

      func Float32FromFloat32(n float32) float32

      func Float32FromFloat64

      func Float32FromFloat64(n float64) float32

      func Float32FromInt16

      func Float32FromInt16(n int16) float32

      func Float32FromInt32

      func Float32FromInt32(n int32) float32

      func Float32FromInt64

      func Float32FromInt64(n int64) float32

      func Float32FromInt8

      func Float32FromInt8(n int8) float32

      func Float32FromUint16

      func Float32FromUint16(n uint16) float32

      func Float32FromUint32

      func Float32FromUint32(n uint32) float32

      func Float32FromUint64

      func Float32FromUint64(n uint64) float32

      func Float32FromUint8

      func Float32FromUint8(n uint8) float32

      func Float32FromUintptr

      func Float32FromUintptr(n uintptr) float32

      func Float64

      func Float64(n float64) float64

      func Float64FromFloat32

      func Float64FromFloat32(n float32) float64

      func Float64FromFloat64

      func Float64FromFloat64(n float64) float64

      func Float64FromInt16

      func Float64FromInt16(n int16) float64

      func Float64FromInt32

      func Float64FromInt32(n int32) float64

      func Float64FromInt64

      func Float64FromInt64(n int64) float64

      func Float64FromInt8

      func Float64FromInt8(n int8) float64

      func Float64FromUint16

      func Float64FromUint16(n uint16) float64

      func Float64FromUint32

      func Float64FromUint32(n uint32) float64

      func Float64FromUint64

      func Float64FromUint64(n uint64) float64

      func Float64FromUint8

      func Float64FromUint8(n uint8) float64

      func Float64FromUintptr

      func Float64FromUintptr(n uintptr) float64

      func GetEnviron

      func GetEnviron() (r []string)

      func GoString

      func GoString(s uintptr) string

      func Int16

      func Int16(n int16) int16

      func Int16FromFloat32

      func Int16FromFloat32(n float32) int16

      func Int16FromFloat64

      func Int16FromFloat64(n float64) int16

      func Int16FromInt16

      func Int16FromInt16(n int16) int16

      func Int16FromInt32

      func Int16FromInt32(n int32) int16

      func Int16FromInt64

      func Int16FromInt64(n int64) int16

      func Int16FromInt8

      func Int16FromInt8(n int8) int16

      func Int16FromUint16

      func Int16FromUint16(n uint16) int16

      func Int16FromUint32

      func Int16FromUint32(n uint32) int16

      func Int16FromUint64

      func Int16FromUint64(n uint64) int16

      func Int16FromUint8

      func Int16FromUint8(n uint8) int16

      func Int16FromUintptr

      func Int16FromUintptr(n uintptr) int16

      func Int32

      func Int32(n int32) int32

      func Int32FromFloat32

      func Int32FromFloat32(n float32) int32

      func Int32FromFloat64

      func Int32FromFloat64(n float64) int32

      func Int32FromInt16

      func Int32FromInt16(n int16) int32

      func Int32FromInt32

      func Int32FromInt32(n int32) int32

      func Int32FromInt64

      func Int32FromInt64(n int64) int32

      func Int32FromInt8

      func Int32FromInt8(n int8) int32

      func Int32FromUint16

      func Int32FromUint16(n uint16) int32

      func Int32FromUint32

      func Int32FromUint32(n uint32) int32

      func Int32FromUint64

      func Int32FromUint64(n uint64) int32

      func Int32FromUint8

      func Int32FromUint8(n uint8) int32

      func Int32FromUintptr

      func Int32FromUintptr(n uintptr) int32

      func Int64

      func Int64(n int64) int64

      func Int64FromFloat32

      func Int64FromFloat32(n float32) int64

      func Int64FromFloat64

      func Int64FromFloat64(n float64) int64

      func Int64FromInt16

      func Int64FromInt16(n int16) int64

      func Int64FromInt32

      func Int64FromInt32(n int32) int64

      func Int64FromInt64

      func Int64FromInt64(n int64) int64

      func Int64FromInt8

      func Int64FromInt8(n int8) int64

      func Int64FromUint16

      func Int64FromUint16(n uint16) int64

      func Int64FromUint32

      func Int64FromUint32(n uint32) int64

      func Int64FromUint64

      func Int64FromUint64(n uint64) int64

      func Int64FromUint8

      func Int64FromUint8(n uint8) int64

      func Int64FromUintptr

      func Int64FromUintptr(n uintptr) int64

      func Int8

      func Int8(n int8) int8

      func Int8FromFloat32

      func Int8FromFloat32(n float32) int8

      func Int8FromFloat64

      func Int8FromFloat64(n float64) int8

      func Int8FromInt16

      func Int8FromInt16(n int16) int8

      func Int8FromInt32

      func Int8FromInt32(n int32) int8

      func Int8FromInt64

      func Int8FromInt64(n int64) int8

      func Int8FromInt8

      func Int8FromInt8(n int8) int8

      func Int8FromUint16

      func Int8FromUint16(n uint16) int8

      func Int8FromUint32

      func Int8FromUint32(n uint32) int8

      func Int8FromUint64

      func Int8FromUint64(n uint64) int8

      func Int8FromUint8

      func Int8FromUint8(n uint8) int8

      func Int8FromUintptr

      func Int8FromUintptr(n uintptr) int8

      func NegInt16

      func NegInt16(n int16) int16

      func NegInt32

      func NegInt32(n int32) int32

      func NegInt64

      func NegInt64(n int64) int64

      func NegInt8

      func NegInt8(n int8) int8

      func NegUint16

      func NegUint16(n uint16) uint16

      func NegUint32

      func NegUint32(n uint32) uint32

      func NegUint64

      func NegUint64(n uint64) uint64

      func NegUint8

      func NegUint8(n uint8) uint8

      func NegUintptr

      func NegUintptr(n uintptr) uintptr

      func PostDecBitFieldPtr16Int16

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

      func PostDecBitFieldPtr16Int32

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

      func PostDecBitFieldPtr16Int64

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

      func PostDecBitFieldPtr16Int8

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

      func PostDecBitFieldPtr16Uint16

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

      func PostDecBitFieldPtr16Uint32

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

      func PostDecBitFieldPtr16Uint64

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

      func PostDecBitFieldPtr16Uint8

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

      func PostDecBitFieldPtr32Int16

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

      func PostDecBitFieldPtr32Int32

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

      func PostDecBitFieldPtr32Int64

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

      func PostDecBitFieldPtr32Int8

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

      func PostDecBitFieldPtr32Uint16

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

      func PostDecBitFieldPtr32Uint32

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

      func PostDecBitFieldPtr32Uint64

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

      func PostDecBitFieldPtr32Uint8

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

      func PostDecBitFieldPtr64Int16

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

      func PostDecBitFieldPtr64Int32

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

      func PostDecBitFieldPtr64Int64

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

      func PostDecBitFieldPtr64Int8

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

      func PostDecBitFieldPtr64Uint16

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

      func PostDecBitFieldPtr64Uint32

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

      func PostDecBitFieldPtr64Uint64

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

      func PostDecBitFieldPtr64Uint8

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

      func PostDecBitFieldPtr8Int16

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

      func PostDecBitFieldPtr8Int32

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

      func PostDecBitFieldPtr8Int64

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

      func PostDecBitFieldPtr8Int8

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

      func PostDecBitFieldPtr8Uint16

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

      func PostDecBitFieldPtr8Uint32

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

      func PostDecBitFieldPtr8Uint64

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

      func PostDecBitFieldPtr8Uint8

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

      func PostDecFloat32

      func PostDecFloat32(p *float32, d float32) float32

      func PostDecFloat64

      func PostDecFloat64(p *float64, d float64) float64

      func PostDecInt16

      func PostDecInt16(p *int16, d int16) int16

      func PostDecInt32

      func PostDecInt32(p *int32, d int32) int32

      func PostDecInt64

      func PostDecInt64(p *int64, d int64) int64

      func PostDecInt8

      func PostDecInt8(p *int8, d int8) int8

      func PostDecUint16

      func PostDecUint16(p *uint16, d uint16) uint16

      func PostDecUint32

      func PostDecUint32(p *uint32, d uint32) uint32

      func PostDecUint64

      func PostDecUint64(p *uint64, d uint64) uint64

      func PostDecUint8

      func PostDecUint8(p *uint8, d uint8) uint8

      func PostDecUintptr

      func PostDecUintptr(p *uintptr, d uintptr) uintptr

      func PostIncBitFieldPtr16Int16

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

      func PostIncBitFieldPtr16Int32

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

      func PostIncBitFieldPtr16Int64

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

      func PostIncBitFieldPtr16Int8

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

      func PostIncBitFieldPtr16Uint16

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

      func PostIncBitFieldPtr16Uint32

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

      func PostIncBitFieldPtr16Uint64

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

      func PostIncBitFieldPtr16Uint8

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

      func PostIncBitFieldPtr32Int16

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

      func PostIncBitFieldPtr32Int32

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

      func PostIncBitFieldPtr32Int64

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

      func PostIncBitFieldPtr32Int8

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

      func PostIncBitFieldPtr32Uint16

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

      func PostIncBitFieldPtr32Uint32

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

      func PostIncBitFieldPtr32Uint64

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

      func PostIncBitFieldPtr32Uint8

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

      func PostIncBitFieldPtr64Int16

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

      func PostIncBitFieldPtr64Int32

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

      func PostIncBitFieldPtr64Int64

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

      func PostIncBitFieldPtr64Int8

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

      func PostIncBitFieldPtr64Uint16

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

      func PostIncBitFieldPtr64Uint32

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

      func PostIncBitFieldPtr64Uint64

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

      func PostIncBitFieldPtr64Uint8

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

      func PostIncBitFieldPtr8Int16

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

      func PostIncBitFieldPtr8Int32

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

      func PostIncBitFieldPtr8Int64

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

      func PostIncBitFieldPtr8Int8

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

      func PostIncBitFieldPtr8Uint16

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

      func PostIncBitFieldPtr8Uint32

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

      func PostIncBitFieldPtr8Uint64

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

      func PostIncBitFieldPtr8Uint8

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

      func PostIncFloat32

      func PostIncFloat32(p *float32, d float32) float32

      func PostIncFloat64

      func PostIncFloat64(p *float64, d float64) float64

      func PostIncInt16

      func PostIncInt16(p *int16, d int16) int16

      func PostIncInt32

      func PostIncInt32(p *int32, d int32) int32

      func PostIncInt64

      func PostIncInt64(p *int64, d int64) int64

      func PostIncInt8

      func PostIncInt8(p *int8, d int8) int8

      func PostIncUint16

      func PostIncUint16(p *uint16, d uint16) uint16

      func PostIncUint32

      func PostIncUint32(p *uint32, d uint32) uint32

      func PostIncUint64

      func PostIncUint64(p *uint64, d uint64) uint64

      func PostIncUint8

      func PostIncUint8(p *uint8, d uint8) uint8

      func PostIncUintptr

      func PostIncUintptr(p *uintptr, d uintptr) uintptr

      func PreDecFloat32

      func PreDecFloat32(p *float32, d float32) float32

      func PreDecFloat64

      func PreDecFloat64(p *float64, d float64) float64

      func PreDecInt16

      func PreDecInt16(p *int16, d int16) int16

      func PreDecInt32

      func PreDecInt32(p *int32, d int32) int32

      func PreDecInt64

      func PreDecInt64(p *int64, d int64) int64

      func PreDecInt8

      func PreDecInt8(p *int8, d int8) int8

      func PreDecUint16

      func PreDecUint16(p *uint16, d uint16) uint16

      func PreDecUint32

      func PreDecUint32(p *uint32, d uint32) uint32

      func PreDecUint64

      func PreDecUint64(p *uint64, d uint64) uint64

      func PreDecUint8

      func PreDecUint8(p *uint8, d uint8) uint8

      func PreDecUintptr

      func PreDecUintptr(p *uintptr, d uintptr) uintptr

      func PreIncFloat32

      func PreIncFloat32(p *float32, d float32) float32

      func PreIncFloat64

      func PreIncFloat64(p *float64, d float64) float64

      func PreIncInt16

      func PreIncInt16(p *int16, d int16) int16

      func PreIncInt32

      func PreIncInt32(p *int32, d int32) int32

      func PreIncInt64

      func PreIncInt64(p *int64, d int64) int64

      func PreIncInt8

      func PreIncInt8(p *int8, d int8) int8

      func PreIncUint16

      func PreIncUint16(p *uint16, d uint16) uint16

      func PreIncUint32

      func PreIncUint32(p *uint32, d uint32) uint32

      func PreIncUint64

      func PreIncUint64(p *uint64, d uint64) uint64

      func PreIncUint8

      func PreIncUint8(p *uint8, d uint8) uint8

      func PreIncUintptr

      func PreIncUintptr(p *uintptr, d uintptr) uintptr

      func SetBitFieldPtr16Int16

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

      func SetBitFieldPtr16Int32

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

      func SetBitFieldPtr16Int64

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

      func SetBitFieldPtr16Int8

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

      func SetBitFieldPtr16Uint16

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

      func SetBitFieldPtr16Uint32

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

      func SetBitFieldPtr16Uint64

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

      func SetBitFieldPtr16Uint8

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

      func SetBitFieldPtr32Int16

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

      func SetBitFieldPtr32Int32

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

      func SetBitFieldPtr32Int64

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

      func SetBitFieldPtr32Int8

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

      func SetBitFieldPtr32Uint16

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

      func SetBitFieldPtr32Uint32

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

      func SetBitFieldPtr32Uint64

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

      func SetBitFieldPtr32Uint8

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

      func SetBitFieldPtr64Int16

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

      func SetBitFieldPtr64Int32

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

      func SetBitFieldPtr64Int64

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

      func SetBitFieldPtr64Int8

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

      func SetBitFieldPtr64Uint16

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

      func SetBitFieldPtr64Uint32

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

      func SetBitFieldPtr64Uint64

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

      func SetBitFieldPtr64Uint8

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

      func SetBitFieldPtr8Int16

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

      func SetBitFieldPtr8Int32

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

      func SetBitFieldPtr8Int64

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

      func SetBitFieldPtr8Int8

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

      func SetBitFieldPtr8Uint16

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

      func SetBitFieldPtr8Uint32

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

      func SetBitFieldPtr8Uint64

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

      func SetBitFieldPtr8Uint8

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

      func Start

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

      func Uint16

      func Uint16(n uint16) uint16

      func Uint16FromFloat32

      func Uint16FromFloat32(n float32) uint16

      func Uint16FromFloat64

      func Uint16FromFloat64(n float64) uint16

      func Uint16FromInt16

      func Uint16FromInt16(n int16) uint16

      func Uint16FromInt32

      func Uint16FromInt32(n int32) uint16

      func Uint16FromInt64

      func Uint16FromInt64(n int64) uint16

      func Uint16FromInt8

      func Uint16FromInt8(n int8) uint16

      func Uint16FromUint16

      func Uint16FromUint16(n uint16) uint16

      func Uint16FromUint32

      func Uint16FromUint32(n uint32) uint16

      func Uint16FromUint64

      func Uint16FromUint64(n uint64) uint16

      func Uint16FromUint8

      func Uint16FromUint8(n uint8) uint16

      func Uint16FromUintptr

      func Uint16FromUintptr(n uintptr) uint16

      func Uint32

      func Uint32(n uint32) uint32

      func Uint32FromFloat32

      func Uint32FromFloat32(n float32) uint32

      func Uint32FromFloat64

      func Uint32FromFloat64(n float64) uint32

      func Uint32FromInt16

      func Uint32FromInt16(n int16) uint32

      func Uint32FromInt32

      func Uint32FromInt32(n int32) uint32

      func Uint32FromInt64

      func Uint32FromInt64(n int64) uint32

      func Uint32FromInt8

      func Uint32FromInt8(n int8) uint32

      func Uint32FromUint16

      func Uint32FromUint16(n uint16) uint32

      func Uint32FromUint32

      func Uint32FromUint32(n uint32) uint32

      func Uint32FromUint64

      func Uint32FromUint64(n uint64) uint32

      func Uint32FromUint8

      func Uint32FromUint8(n uint8) uint32

      func Uint32FromUintptr

      func Uint32FromUintptr(n uintptr) uint32

      func Uint64

      func Uint64(n uint64) uint64

      func Uint64FromFloat32

      func Uint64FromFloat32(n float32) uint64

      func Uint64FromFloat64

      func Uint64FromFloat64(n float64) uint64

      func Uint64FromInt16

      func Uint64FromInt16(n int16) uint64

      func Uint64FromInt32

      func Uint64FromInt32(n int32) uint64

      func Uint64FromInt64

      func Uint64FromInt64(n int64) uint64

      func Uint64FromInt8

      func Uint64FromInt8(n int8) uint64

      func Uint64FromUint16

      func Uint64FromUint16(n uint16) uint64

      func Uint64FromUint32

      func Uint64FromUint32(n uint32) uint64

      func Uint64FromUint64

      func Uint64FromUint64(n uint64) uint64

      func Uint64FromUint8

      func Uint64FromUint8(n uint8) uint64

      func Uint64FromUintptr

      func Uint64FromUintptr(n uintptr) uint64

      func Uint8

      func Uint8(n uint8) uint8

      func Uint8FromFloat32

      func Uint8FromFloat32(n float32) uint8

      func Uint8FromFloat64

      func Uint8FromFloat64(n float64) uint8

      func Uint8FromInt16

      func Uint8FromInt16(n int16) uint8

      func Uint8FromInt32

      func Uint8FromInt32(n int32) uint8

      func Uint8FromInt64

      func Uint8FromInt64(n int64) uint8

      func Uint8FromInt8

      func Uint8FromInt8(n int8) uint8

      func Uint8FromUint16

      func Uint8FromUint16(n uint16) uint8

      func Uint8FromUint32

      func Uint8FromUint32(n uint32) uint8

      func Uint8FromUint64

      func Uint8FromUint64(n uint64) uint8

      func Uint8FromUint8

      func Uint8FromUint8(n uint8) uint8

      func Uint8FromUintptr

      func Uint8FromUintptr(n uintptr) uint8

      func Uintptr

      func Uintptr(n uintptr) uintptr

      func UintptrFromFloat32

      func UintptrFromFloat32(n float32) uintptr

      func UintptrFromFloat64

      func UintptrFromFloat64(n float64) uintptr

      func UintptrFromInt16

      func UintptrFromInt16(n int16) uintptr

      func UintptrFromInt32

      func UintptrFromInt32(n int32) uintptr

      func UintptrFromInt64

      func UintptrFromInt64(n int64) uintptr

      func UintptrFromInt8

      func UintptrFromInt8(n int8) uintptr

      func UintptrFromUint16

      func UintptrFromUint16(n uint16) uintptr

      func UintptrFromUint32

      func UintptrFromUint32(n uint32) uintptr

      func UintptrFromUint64

      func UintptrFromUint64(n uint64) uintptr

      func UintptrFromUint8

      func UintptrFromUint8(n uint8) uintptr

      func UintptrFromUintptr

      func UintptrFromUintptr(n uintptr) uintptr

      func VaFloat32

      func VaFloat32(app *uintptr) float32

      func VaFloat64

      func VaFloat64(app *uintptr) float64

      func VaInt32

      func VaInt32(app *uintptr) int32

      func VaInt64

      func VaInt64(app *uintptr) int64

      func VaList

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

        VaList fills a varargs list at p with args and returns uintptr(p). The list must have been allocated by caller and it must not be in Go managed memory, ie. it must be pinned. Caller is responsible for freeing the list.

        Individual arguments must be one of int, uint, int32, uint32, int64, uint64, float64, uintptr or Intptr. Other types will panic.

        Note: The C translated to Go varargs ABI alignment for all types is 8 at all architectures.

        func VaUint32

        func VaUint32(app *uintptr) uint32

        func VaUint64

        func VaUint64(app *uintptr) uint64

        func VaUintptr

        func VaUintptr(app *uintptr) uintptr

        func X__assert_fail

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

          void __assert_fail(const char * assertion, const char * file, unsigned int line, const char * function);

          func X__builtin_abort

          func X__builtin_abort(t *TLS)

          func X__builtin_abs

          func X__builtin_abs(t *TLS, j int32) int32

          func X__builtin_copysign

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

          func X__builtin_copysignf

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

          func X__builtin_exit

          func X__builtin_exit(t *TLS, status int32)

          func X__builtin_expect

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

          func X__builtin_fabs

          func X__builtin_fabs(t *TLS, x float64) float64

          func X__builtin_free

          func X__builtin_free(t *TLS, ptr uintptr)

          func X__builtin_malloc

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

          func X__builtin_memcmp

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

          func X__builtin_memcpy

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

          func X__builtin_memset

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

          func X__builtin_prefetch

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

          func X__builtin_printf

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

          func X__builtin_snprintf

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

          func X__builtin_sprintf

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

          func X__builtin_strchr

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

          func X__builtin_strcmp

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

          func X__builtin_strcpy

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

          func X__builtin_strlen

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

          func X__builtin_trap

          func X__builtin_trap(t *TLS)

          func X__builtin_unreachable

          func X__builtin_unreachable(t *TLS)

          func X__ccgo_in6addr_anyp

          func X__ccgo_in6addr_anyp(t *TLS) uintptr

          func X__ctype_b_loc

          func X__ctype_b_loc(t *TLS) uintptr

            const unsigned short * * __ctype_b_loc (void);

            func X__errno_location

            func X__errno_location(t *TLS) uintptr

              int * __errno_location(void);

              func X__isnan

              func X__isnan(t *TLS, arg float64) int32

              func X__isnanf

              func X__isnanf(t *TLS, arg float32) int32

              func X__isnanl

              func X__isnanl(t *TLS, arg float64) int32

              func X__isoc99_sscanf

              func X__isoc99_sscanf(t *TLS, str, format, va uintptr) int32

                int __isoc99_sscanf(const char *str, const char *format, ...);

                func X_exit

                func X_exit(t *TLS, status int32)

                  void _exit(int status);

                  func Xabort

                  func Xabort(t *TLS)

                  func Xabs

                  func Xabs(t *TLS, j int32) int32

                    int abs(int j);

                    func Xaccept

                    func Xaccept(t *TLS, sockfd int32, addr uintptr, addrlen uintptr) int32

                      int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

                      func Xaccess

                      func Xaccess(t *TLS, pathname uintptr, mode int32) int32

                        int access(const char *pathname, int mode);

                        func Xacos

                        func Xacos(t *TLS, x float64) float64

                        func Xalarm

                        func Xalarm(t *TLS, seconds uint32) uint32

                          unsigned int alarm(unsigned int seconds);

                          func Xasin

                          func Xasin(t *TLS, x float64) float64

                          func Xatan

                          func Xatan(t *TLS, x float64) float64

                          func Xatan2

                          func Xatan2(t *TLS, x, y float64) float64

                          func Xatof

                          func Xatof(t *TLS, nptr uintptr) float64

                            double atof(const char *nptr);

                            func Xatoi

                            func Xatoi(t *TLS, nptr uintptr) int32

                              int atoi(const char *nptr);

                              func Xatol

                              func Xatol(t *TLS, nptr uintptr) long

                                long atol(const char *nptr);

                                func Xbacktrace

                                func Xbacktrace(t *TLS, buf uintptr, size int32) int32

                                  int backtrace(void **buffer, int size);

                                  func Xbacktrace_symbols_fd

                                  func Xbacktrace_symbols_fd(t *TLS, buffer uintptr, size, fd int32)

                                    void backtrace_symbols_fd(void *const *buffer, int size, int fd);

                                    func Xbind

                                    func Xbind(t *TLS, sockfd int32, addr uintptr, addrlen uint32) int32

                                      int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

                                      func Xcalloc

                                      func Xcalloc(t *TLS, n, size types.Size_t) uintptr

                                        void *calloc(size_t nmemb, size_t size);

                                        func Xceil

                                        func Xceil(t *TLS, x float64) float64

                                        func Xcfgetospeed

                                        func Xcfgetospeed(t *TLS, termios_p uintptr) termios.Speed_t

                                          speed_t cfgetospeed(const struct termios *termios_p);

                                          func Xcfsetispeed

                                          func Xcfsetispeed(t *TLS, termios_p uintptr, speed uint32) int32

                                            int cfsetispeed(struct termios *termios_p, speed_t speed);

                                            func Xcfsetospeed

                                            func Xcfsetospeed(t *TLS, termios_p uintptr, speed uint32) int32

                                              int cfsetospeed(struct termios *termios_p, speed_t speed);

                                              func Xchdir

                                              func Xchdir(t *TLS, path uintptr) int32

                                                int chdir(const char *path);

                                                func Xchmod

                                                func Xchmod(t *TLS, pathname uintptr, mode types.Mode_t) int32

                                                  int chmod(const char *pathname, mode_t mode)

                                                  func Xchown

                                                  func Xchown(t *TLS, pathname uintptr, owner types.Uid_t, group types.Gid_t) int32

                                                    int chown(const char *pathname, uid_t owner, gid_t group);

                                                    func Xclose

                                                    func Xclose(t *TLS, fd int32) int32

                                                      int close(int fd);

                                                      func Xclosedir

                                                      func Xclosedir(t *TLS, dir uintptr) int32

                                                        int closedir(DIR *dirp);

                                                        func Xconnect

                                                        func Xconnect(t *TLS, sockfd int32, addr uintptr, addrlen uint32) int32

                                                          int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

                                                          func Xcopysign

                                                          func Xcopysign(t *TLS, x, y float64) float64

                                                          func Xcopysignf

                                                          func Xcopysignf(t *TLS, x, y float32) float32

                                                          func Xcos

                                                          func Xcos(t *TLS, x float64) float64

                                                          func Xcosf

                                                          func Xcosf(t *TLS, x float32) float32

                                                          func Xcosh

                                                          func Xcosh(t *TLS, x float64) float64

                                                          func Xdlclose

                                                          func Xdlclose(t *TLS, handle uintptr) int32

                                                            int dlclose(void *handle);

                                                            func Xdlerror

                                                            func Xdlerror(t *TLS) uintptr

                                                              char *dlerror(void);

                                                              func Xdlopen

                                                              func Xdlopen(t *TLS, filename uintptr, flags int32) uintptr

                                                                void *dlopen(const char *filename, int flags);

                                                                func Xdlsym

                                                                func Xdlsym(t *TLS, handle, symbol uintptr) uintptr

                                                                  void *dlsym(void *handle, const char *symbol);

                                                                  func Xdup2

                                                                  func Xdup2(t *TLS, oldfd, newfd int32) int32

                                                                    int dup2(int oldfd, int newfd);

                                                                    func Xexecvp

                                                                    func Xexecvp(t *TLS, file, argv uintptr) int32

                                                                      int execvp(const char *file, char *const argv[]);

                                                                      func Xexit

                                                                      func Xexit(t *TLS, status int32)

                                                                      func Xexp

                                                                      func Xexp(t *TLS, x float64) float64

                                                                      func Xfabs

                                                                      func Xfabs(t *TLS, x float64) float64

                                                                      func Xfabsf

                                                                      func Xfabsf(t *TLS, x float32) float32

                                                                      func Xfchmod

                                                                      func Xfchmod(t *TLS, fd int32, mode types.Mode_t) int32

                                                                        int fchmod(int fd, mode_t mode);

                                                                        func Xfchown

                                                                        func Xfchown(t *TLS, fd int32, owner types.Uid_t, group types.Gid_t) int32

                                                                          int fchown(int fd, uid_t owner, gid_t group);

                                                                          func Xfclose

                                                                          func Xfclose(t *TLS, stream uintptr) int32

                                                                            int fclose(FILE *stream);

                                                                            func Xfcntl

                                                                            func Xfcntl(t *TLS, fd, cmd int32, args uintptr) int32

                                                                              int fcntl(int fd, int cmd, ... /* arg */ );

                                                                              func Xfcntl64

                                                                              func Xfcntl64(t *TLS, fd, cmd int32, args uintptr) int32

                                                                                int fcntl(int fd, int cmd, ... /* arg */ );

                                                                                func Xfdopen

                                                                                func Xfdopen(t *TLS, fd int32, mode uintptr) uintptr

                                                                                  FILE *fdopen(int fd, const char *mode);

                                                                                  func Xferror

                                                                                  func Xferror(t *TLS, stream uintptr) int32

                                                                                    int ferror(FILE *stream);

                                                                                    func Xfflush

                                                                                    func Xfflush(t *TLS, stream uintptr) int32

                                                                                      int fflush(FILE *stream);

                                                                                      func Xfgetc

                                                                                      func Xfgetc(t *TLS, stream uintptr) int32

                                                                                        int fgetc(FILE *stream);

                                                                                        func Xfgets

                                                                                        func Xfgets(t *TLS, s uintptr, size int32, stream uintptr) uintptr

                                                                                          char *fgets(char *s, int size, FILE *stream);

                                                                                          func Xfileno

                                                                                          func Xfileno(t *TLS, stream uintptr) int32

                                                                                            int fileno(FILE *stream);

                                                                                            func Xfloor

                                                                                            func Xfloor(t *TLS, x float64) float64

                                                                                            func Xfmod

                                                                                            func Xfmod(t *TLS, x, y float64) float64

                                                                                            func Xfopen

                                                                                            func Xfopen(t *TLS, pathname, mode uintptr) uintptr

                                                                                              FILE *fopen(const char *pathname, const char *mode);

                                                                                              func Xfopen64

                                                                                              func Xfopen64(t *TLS, pathname, mode uintptr) uintptr

                                                                                                FILE *fopen64(const char *pathname, const char *mode);

                                                                                                func Xfork

                                                                                                func Xfork(t *TLS) int32

                                                                                                  pid_t fork(void);

                                                                                                  func Xfprintf

                                                                                                  func Xfprintf(t *TLS, stream, format, args uintptr) int32

                                                                                                    int fprintf(FILE *stream, const char *format, ...);

                                                                                                    func Xfputc

                                                                                                    func Xfputc(t *TLS, c int32, stream uintptr) int32

                                                                                                      int fputc(int c, FILE *stream);

                                                                                                      func Xfputs

                                                                                                      func Xfputs(t *TLS, s, stream uintptr) int32

                                                                                                        int fputs(const char *s, FILE *stream);

                                                                                                        func Xfread

                                                                                                        func Xfread(t *TLS, ptr uintptr, size, nmemb types.Size_t, stream uintptr) types.Size_t

                                                                                                          size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);

                                                                                                          func Xfree

                                                                                                          func Xfree(t *TLS, p uintptr)

                                                                                                            void free(void *ptr);

                                                                                                            func Xfreeaddrinfo

                                                                                                            func Xfreeaddrinfo(t *TLS, res uintptr)

                                                                                                              void freeaddrinfo(struct addrinfo *res);

                                                                                                              func Xfrexp

                                                                                                              func Xfrexp(t *TLS, x float64, exp uintptr) float64

                                                                                                              func Xfseek

                                                                                                              func Xfseek(t *TLS, stream uintptr, offset long, whence int32) int32

                                                                                                                int fseek(FILE *stream, long offset, int whence);

                                                                                                                func Xfstat

                                                                                                                func Xfstat(t *TLS, fd int32, statbuf uintptr) int32

                                                                                                                  int fstat(int fd, struct stat *statbuf);

                                                                                                                  func Xfstat64

                                                                                                                  func Xfstat64(t *TLS, fd int32, statbuf uintptr) int32

                                                                                                                    int fstat(int fd, struct stat *statbuf);

                                                                                                                    func Xfsync

                                                                                                                    func Xfsync(t *TLS, fd int32) int32

                                                                                                                      int fsync(int fd);

                                                                                                                      func Xftell

                                                                                                                      func Xftell(t *TLS, stream uintptr) long

                                                                                                                        long ftell(FILE *stream);

                                                                                                                        func Xftruncate

                                                                                                                        func Xftruncate(t *TLS, fd int32, length types.Off_t) int32

                                                                                                                          int ftruncate(int fd, off_t length);

                                                                                                                          func Xftruncate64

                                                                                                                          func Xftruncate64(t *TLS, fd int32, length types.X__off64_t) int32

                                                                                                                            int ftruncate(int fd, off_t length);

                                                                                                                            func Xfts_close

                                                                                                                            func Xfts_close(t *TLS, ftsp uintptr) int32

                                                                                                                              int fts_close(FTS *ftsp);

                                                                                                                              func Xfts_open

                                                                                                                              func Xfts_open(t *TLS, path_argv uintptr, options int32, compar uintptr) uintptr

                                                                                                                                FTS *fts_open(char * const *path_argv, int options, int (*compar)(const FTSENT **, const FTSENT **));

                                                                                                                                func Xfts_read

                                                                                                                                func Xfts_read(t *TLS, ftsp uintptr) uintptr

                                                                                                                                  FTSENT *fts_read(FTS *ftsp);

                                                                                                                                  func Xfwrite

                                                                                                                                  func Xfwrite(t *TLS, ptr uintptr, size, nmemb types.Size_t, stream uintptr) types.Size_t

                                                                                                                                    size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);

                                                                                                                                    func Xgai_strerror

                                                                                                                                    func Xgai_strerror(t *TLS, errcode int32) uintptr

                                                                                                                                      const char *gai_strerror(int errcode);

                                                                                                                                      func Xgetaddrinfo

                                                                                                                                      func Xgetaddrinfo(t *TLS, node, service, hints, res uintptr) int32

                                                                                                                                        int getaddrinfo(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res);

                                                                                                                                        func Xgetcwd

                                                                                                                                        func Xgetcwd(t *TLS, buf uintptr, size types.Size_t) uintptr

                                                                                                                                          char *getcwd(char *buf, size_t size);

                                                                                                                                          func Xgetenv

                                                                                                                                          func Xgetenv(t *TLS, name uintptr) uintptr

                                                                                                                                            char *getenv(const char *name);

                                                                                                                                            func Xgeteuid

                                                                                                                                            func Xgeteuid(t *TLS) types.Uid_t

                                                                                                                                              uid_t geteuid(void);

                                                                                                                                              func Xgetgrgid

                                                                                                                                              func Xgetgrgid(t *TLS, gid uint32) uintptr

                                                                                                                                                struct group *getgrgid(gid_t gid);

                                                                                                                                                func Xgetgrnam

                                                                                                                                                func Xgetgrnam(t *TLS, name uintptr) uintptr

                                                                                                                                                  struct group *getgrnam(const char *name);

                                                                                                                                                  func Xgethostbyaddr

                                                                                                                                                  func Xgethostbyaddr(t *TLS, addr uintptr, len socket.Socklen_t, type1 int32) uintptr

                                                                                                                                                    struct hostent *gethostbyaddr(const void *addr, socklen_t len, int type);

                                                                                                                                                    func Xgethostbyname

                                                                                                                                                    func Xgethostbyname(t *TLS, name uintptr) uintptr

                                                                                                                                                      struct hostent *gethostbyname(const char *name);

                                                                                                                                                      func Xgetnameinfo

                                                                                                                                                      func Xgetnameinfo(t *TLS, addr uintptr, addrlen socket.Socklen_t, host uintptr, hostlen socket.Socklen_t, serv uintptr, servlen socket.Socklen_t, flags int32) int32

                                                                                                                                                        int getnameinfo(const struct sockaddr *addr, socklen_t addrlen, char *host, socklen_t hostlen, char *serv, socklen_t servlen, int flags);

                                                                                                                                                        func Xgetpeername

                                                                                                                                                        func Xgetpeername(t *TLS, sockfd int32, addr uintptr, addrlen uintptr) int32

                                                                                                                                                          int getpeername(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

                                                                                                                                                          func Xgetpid

                                                                                                                                                          func Xgetpid(t *TLS) int32

                                                                                                                                                            pid_t getpid(void);

                                                                                                                                                            func Xgetpwnam

                                                                                                                                                            func Xgetpwnam(t *TLS, name uintptr) uintptr

                                                                                                                                                              struct passwd *getpwnam(const char *name);

                                                                                                                                                              func Xgetpwuid

                                                                                                                                                              func Xgetpwuid(t *TLS, uid uint32) uintptr

                                                                                                                                                                struct passwd *getpwuid(uid_t uid);

                                                                                                                                                                func Xgetrlimit

                                                                                                                                                                func Xgetrlimit(t *TLS, resource int32, rlim uintptr) int32

                                                                                                                                                                  int getrlimit(int resource, struct rlimit *rlim);

                                                                                                                                                                  func Xgetrusage

                                                                                                                                                                  func Xgetrusage(t *TLS, who int32, usage uintptr) int32

                                                                                                                                                                    int getrusage(int who, struct rusage *usage);

                                                                                                                                                                    func Xgetservbyname

                                                                                                                                                                    func Xgetservbyname(t *TLS, name, proto uintptr) uintptr

                                                                                                                                                                      struct servent *getservbyname(const char *name, const char *proto);

                                                                                                                                                                      func Xgetsockname

                                                                                                                                                                      func Xgetsockname(t *TLS, sockfd int32, addr, addrlen uintptr) int32

                                                                                                                                                                        int getsockname(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

                                                                                                                                                                        func Xgetsockopt

                                                                                                                                                                        func Xgetsockopt(t *TLS, sockfd, level, optname int32, optval, optlen uintptr) int32

                                                                                                                                                                          int getsockopt(int sockfd, int level, int optname, void *optval, socklen_t *optlen);

                                                                                                                                                                          func Xgettimeofday

                                                                                                                                                                          func Xgettimeofday(t *TLS, tv, tz uintptr) int32

                                                                                                                                                                            int gettimeofday(struct timeval *tv, struct timezone *tz);

                                                                                                                                                                            func Xgetuid

                                                                                                                                                                            func Xgetuid(t *TLS) types.Uid_t

                                                                                                                                                                              uid_t getuid(void);

                                                                                                                                                                              func Xgmtime_r

                                                                                                                                                                              func Xgmtime_r(t *TLS, timep, result uintptr) uintptr

                                                                                                                                                                                struct tm *gmtime_r(const time_t *timep, struct tm *result);

                                                                                                                                                                                func Xhtonl

                                                                                                                                                                                func Xhtonl(t *TLS, hostlong uint32) uint32

                                                                                                                                                                                  uint32_t htonl(uint32_t hostlong);

                                                                                                                                                                                  func Xhtons

                                                                                                                                                                                  func Xhtons(t *TLS, hostshort uint16) uint16

                                                                                                                                                                                    uint16_t htons(uint16_t hostshort);

                                                                                                                                                                                    func Xhypot

                                                                                                                                                                                    func Xhypot(t *TLS, x, y float64) float64

                                                                                                                                                                                    func Xinet_ntoa

                                                                                                                                                                                    func Xinet_ntoa(t *TLS, in1 in.In_addr) uintptr

                                                                                                                                                                                      char *inet_ntoa(struct in_addr in);

                                                                                                                                                                                      func Xioctl

                                                                                                                                                                                      func Xioctl(t *TLS, fd int32, request ulong, va uintptr) int32

                                                                                                                                                                                        int ioctl(int fd, unsigned long request, ...);

                                                                                                                                                                                        func Xisatty

                                                                                                                                                                                        func Xisatty(t *TLS, fd int32) int32

                                                                                                                                                                                          int isatty(int fd);

                                                                                                                                                                                          func Xisnan

                                                                                                                                                                                          func Xisnan(t *TLS, x float64) int32

                                                                                                                                                                                          func Xisnanf

                                                                                                                                                                                          func Xisnanf(t *TLS, x float32) int32

                                                                                                                                                                                          func Xisnanl

                                                                                                                                                                                          func Xisnanl(t *TLS, x float64) int32

                                                                                                                                                                                          func Xldexp

                                                                                                                                                                                          func Xldexp(t *TLS, x float64, exp int32) float64
                                                                                                                                                                                          func Xlink(t *TLS, oldpath, newpath uintptr) int32

                                                                                                                                                                                            int link(const char *oldpath, const char *newpath);

                                                                                                                                                                                            func Xlisten

                                                                                                                                                                                            func Xlisten(t *TLS, sockfd, backlog int32) int32

                                                                                                                                                                                              int listen(int sockfd, int backlog);

                                                                                                                                                                                              func Xlocaltime

                                                                                                                                                                                              func Xlocaltime(_ *TLS, timep uintptr) uintptr

                                                                                                                                                                                                struct tm *localtime(const time_t *timep);

                                                                                                                                                                                                func Xlocaltime_r

                                                                                                                                                                                                func Xlocaltime_r(_ *TLS, timep, result uintptr) uintptr

                                                                                                                                                                                                  struct tm *localtime_r(const time_t *timep, struct tm *result);

                                                                                                                                                                                                  func Xlog

                                                                                                                                                                                                  func Xlog(t *TLS, x float64) float64

                                                                                                                                                                                                  func Xlog10

                                                                                                                                                                                                  func Xlog10(t *TLS, x float64) float64

                                                                                                                                                                                                  func Xlseek

                                                                                                                                                                                                  func Xlseek(t *TLS, fd int32, offset types.Off_t, whence int32) types.Off_t

                                                                                                                                                                                                    off_t lseek(int fd, off_t offset, int whence);

                                                                                                                                                                                                    func Xlseek64

                                                                                                                                                                                                    func Xlseek64(t *TLS, fd int32, offset types.X__off64_t, whence int32) types.X__off64_t

                                                                                                                                                                                                      off64_t lseek64(int fd, off64_t offset, int whence);

                                                                                                                                                                                                      func Xlstat

                                                                                                                                                                                                      func Xlstat(t *TLS, pathname, statbuf uintptr) int32

                                                                                                                                                                                                        int lstat(const char *pathname, struct stat *statbuf);

                                                                                                                                                                                                        func Xlstat64

                                                                                                                                                                                                        func Xlstat64(t *TLS, pathname, statbuf uintptr) int32

                                                                                                                                                                                                          int lstat(const char *pathname, struct stat *statbuf);

                                                                                                                                                                                                          func Xmalloc

                                                                                                                                                                                                          func Xmalloc(t *TLS, n types.Size_t) uintptr

                                                                                                                                                                                                            void *malloc(size_t size);

                                                                                                                                                                                                            func Xmemchr

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

                                                                                                                                                                                                              void *memchr(const void *s, int c, size_t n);

                                                                                                                                                                                                              func Xmemcmp

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

                                                                                                                                                                                                                int memcmp(const void *s1, const void *s2, size_t n);

                                                                                                                                                                                                                func Xmemcpy

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

                                                                                                                                                                                                                  void *memcpy(void *dest, const void *src, size_t n);

                                                                                                                                                                                                                  func Xmemmove

                                                                                                                                                                                                                  func Xmemmove(t *TLS, dest, src uintptr, n types.Size_t) uintptr

                                                                                                                                                                                                                    void *memmove(void *dest, const void *src, size_t n);

                                                                                                                                                                                                                    func Xmemset

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

                                                                                                                                                                                                                      void *memset(void *s, int c, size_t n)

                                                                                                                                                                                                                      func Xmkdir

                                                                                                                                                                                                                      func Xmkdir(t *TLS, path uintptr, mode types.Mode_t) int32

                                                                                                                                                                                                                        int mkdir(const char *path, mode_t mode);

                                                                                                                                                                                                                        func Xmkfifo

                                                                                                                                                                                                                        func Xmkfifo(t *TLS, pathname uintptr, mode types.Mode_t) int32

                                                                                                                                                                                                                          int mkfifo(const char *pathname, mode_t mode);

                                                                                                                                                                                                                          func Xmknod

                                                                                                                                                                                                                          func Xmknod(t *TLS, pathname uintptr, mode types.Mode_t, dev types.Dev_t) int32

                                                                                                                                                                                                                            int mknod(const char *pathname, mode_t mode, dev_t dev);

                                                                                                                                                                                                                            func Xmkstemp

                                                                                                                                                                                                                            func Xmkstemp(t *TLS, template uintptr) int32

                                                                                                                                                                                                                              int mkstemp(char *template);

                                                                                                                                                                                                                              func Xmkstemps

                                                                                                                                                                                                                              func Xmkstemps(t *TLS, template uintptr, suffixlen int32) int32

                                                                                                                                                                                                                                int mkstemps(char *template, int suffixlen);

                                                                                                                                                                                                                                func Xmktime

                                                                                                                                                                                                                                func Xmktime(t *TLS, ptm uintptr) types.Time_t

                                                                                                                                                                                                                                  time_t mktime(struct tm *tm);

                                                                                                                                                                                                                                  func Xmmap64

                                                                                                                                                                                                                                  func Xmmap64(t *TLS, addr uintptr, length types.Size_t, prot, flags, fd int32, offset types.X__off64_t) uintptr

                                                                                                                                                                                                                                    void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);

                                                                                                                                                                                                                                    func Xmodf

                                                                                                                                                                                                                                    func Xmodf(t *TLS, x float64, iptr uintptr) float64

                                                                                                                                                                                                                                    func Xmunmap

                                                                                                                                                                                                                                    func Xmunmap(t *TLS, addr uintptr, length types.Size_t) int32

                                                                                                                                                                                                                                      int munmap(void *addr, size_t length);

                                                                                                                                                                                                                                      func Xnl_langinfo

                                                                                                                                                                                                                                      func Xnl_langinfo(t *TLS, item langinfo.Nl_item) uintptr

                                                                                                                                                                                                                                        char *nl_langinfo(nl_item item);

                                                                                                                                                                                                                                        func Xntohs

                                                                                                                                                                                                                                        func Xntohs(t *TLS, netshort uint16) uint16

                                                                                                                                                                                                                                        func Xopen

                                                                                                                                                                                                                                        func Xopen(t *TLS, pathname uintptr, flags int32, args uintptr) int32

                                                                                                                                                                                                                                          int open(const char *pathname, int flags, ...);

                                                                                                                                                                                                                                          func Xopen64

                                                                                                                                                                                                                                          func Xopen64(t *TLS, pathname uintptr, flags int32, args uintptr) int32

                                                                                                                                                                                                                                            int open(const char *pathname, int flags, ...);

                                                                                                                                                                                                                                            func Xopendir

                                                                                                                                                                                                                                            func Xopendir(t *TLS, name uintptr) uintptr

                                                                                                                                                                                                                                              DIR *opendir(const char *name);

                                                                                                                                                                                                                                              func Xpclose

                                                                                                                                                                                                                                              func Xpclose(t *TLS, stream uintptr) int32

                                                                                                                                                                                                                                                int pclose(FILE *stream);

                                                                                                                                                                                                                                                func Xperror

                                                                                                                                                                                                                                                func Xperror(t *TLS, s uintptr)

                                                                                                                                                                                                                                                  void perror(const char *s);

                                                                                                                                                                                                                                                  func Xpipe

                                                                                                                                                                                                                                                  func Xpipe(t *TLS, pipefd uintptr) int32

                                                                                                                                                                                                                                                    int pipe(int pipefd[2]);

                                                                                                                                                                                                                                                    func Xpopen

                                                                                                                                                                                                                                                    func Xpopen(t *TLS, command, type1 uintptr) uintptr

                                                                                                                                                                                                                                                      FILE *popen(const char *command, const char *type);

                                                                                                                                                                                                                                                      func Xpow

                                                                                                                                                                                                                                                      func Xpow(t *TLS, x, y float64) float64

                                                                                                                                                                                                                                                      func Xprintf

                                                                                                                                                                                                                                                      func Xprintf(t *TLS, format, args uintptr) int32

                                                                                                                                                                                                                                                        int printf(const char *format, ...);

                                                                                                                                                                                                                                                        func Xputc

                                                                                                                                                                                                                                                        func Xputc(t *TLS, c int32, fp uintptr) int32

                                                                                                                                                                                                                                                          int putc(int c, FILE *stream);

                                                                                                                                                                                                                                                          func Xputchar

                                                                                                                                                                                                                                                          func Xputchar(t *TLS, c int32) int32

                                                                                                                                                                                                                                                            int putchar(int c);

                                                                                                                                                                                                                                                            func Xqsort

                                                                                                                                                                                                                                                            func Xqsort(t *TLS, base uintptr, nmemb, size types.Size_t, compar uintptr)

                                                                                                                                                                                                                                                              void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *));

                                                                                                                                                                                                                                                              func Xraise

                                                                                                                                                                                                                                                              func Xraise(t *TLS, sig int32) int32

                                                                                                                                                                                                                                                                int raise(int sig);

                                                                                                                                                                                                                                                                func Xrand

                                                                                                                                                                                                                                                                func Xrand(t *TLS) int32

                                                                                                                                                                                                                                                                  int rand(void);

                                                                                                                                                                                                                                                                  func Xread

                                                                                                                                                                                                                                                                  func Xread(t *TLS, fd int32, buf uintptr, count types.Size_t) types.Ssize_t

                                                                                                                                                                                                                                                                    ssize_t read(int fd, void *buf, size_t count);

                                                                                                                                                                                                                                                                    func Xreaddir

                                                                                                                                                                                                                                                                    func Xreaddir(t *TLS, dirp uintptr) uintptr

                                                                                                                                                                                                                                                                      struct dirent *readdir(DIR *dirp);

                                                                                                                                                                                                                                                                      func Xreaddir64

                                                                                                                                                                                                                                                                      func Xreaddir64(t *TLS, dirp uintptr) uintptr

                                                                                                                                                                                                                                                                        struct dirent *readdir(DIR *dirp);

                                                                                                                                                                                                                                                                        func Xreadlink(t *TLS, path, buf uintptr, bufsize types.Size_t) types.Ssize_t

                                                                                                                                                                                                                                                                          ssize_t readlink(const char *restrict path, char *restrict buf, size_t bufsize);

                                                                                                                                                                                                                                                                          func Xrealloc

                                                                                                                                                                                                                                                                          func Xrealloc(t *TLS, ptr uintptr, size types.Size_t) uintptr

                                                                                                                                                                                                                                                                            void *realloc(void *ptr, size_t size);

                                                                                                                                                                                                                                                                            func Xrealpath

                                                                                                                                                                                                                                                                            func Xrealpath(t *TLS, path, resolved_path uintptr) uintptr

                                                                                                                                                                                                                                                                              char *realpath(const char *path, char *resolved_path);

                                                                                                                                                                                                                                                                              func Xrecv

                                                                                                                                                                                                                                                                              func Xrecv(t *TLS, sockfd int32, buf uintptr, len types.Size_t, flags int32) types.Ssize_t

                                                                                                                                                                                                                                                                                ssize_t recv(int sockfd, void *buf, size_t len, int flags);

                                                                                                                                                                                                                                                                                func Xrename

                                                                                                                                                                                                                                                                                func Xrename(t *TLS, oldpath, newpath uintptr) int32

                                                                                                                                                                                                                                                                                  int rename(const char *oldpath, const char *newpath);

                                                                                                                                                                                                                                                                                  func Xrewind

                                                                                                                                                                                                                                                                                  func Xrewind(t *TLS, stream uintptr)

                                                                                                                                                                                                                                                                                    void rewind(FILE *stream);

                                                                                                                                                                                                                                                                                    func Xrmdir

                                                                                                                                                                                                                                                                                    func Xrmdir(t *TLS, pathname uintptr) int32

                                                                                                                                                                                                                                                                                      int rmdir(const char *pathname);

                                                                                                                                                                                                                                                                                      func Xround

                                                                                                                                                                                                                                                                                      func Xround(t *TLS, x float64) float64

                                                                                                                                                                                                                                                                                      func Xselect

                                                                                                                                                                                                                                                                                      func Xselect(t *TLS, nfds int32, readfds, writefds, exceptfds, timeout uintptr) int32

                                                                                                                                                                                                                                                                                        int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

                                                                                                                                                                                                                                                                                        func Xsend

                                                                                                                                                                                                                                                                                        func Xsend(t *TLS, sockfd int32, buf uintptr, len types.Size_t, flags int32) types.Ssize_t

                                                                                                                                                                                                                                                                                          ssize_t send(int sockfd, const void *buf, size_t len, int flags);

                                                                                                                                                                                                                                                                                          func Xsetlocale

                                                                                                                                                                                                                                                                                          func Xsetlocale(t *TLS, category int32, locale uintptr) uintptr

                                                                                                                                                                                                                                                                                            char *setlocale(int category, const char *locale);

                                                                                                                                                                                                                                                                                            func Xsetrlimit

                                                                                                                                                                                                                                                                                            func Xsetrlimit(t *TLS, resource int32, rlim uintptr) int32

                                                                                                                                                                                                                                                                                              int setrlimit(int resource, const struct rlimit *rlim);

                                                                                                                                                                                                                                                                                              func Xsetsockopt

                                                                                                                                                                                                                                                                                              func Xsetsockopt(t *TLS, sockfd, level, optname int32, optval uintptr, optlen socket.Socklen_t) int32

                                                                                                                                                                                                                                                                                                int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen);

                                                                                                                                                                                                                                                                                                func Xsetvbuf

                                                                                                                                                                                                                                                                                                func Xsetvbuf(t *TLS, stream, buf uintptr, mode int32, size types.Size_t) int32

                                                                                                                                                                                                                                                                                                  int setvbuf(FILE *stream, char *buf, int mode, size_t size);

                                                                                                                                                                                                                                                                                                  func Xshutdown

                                                                                                                                                                                                                                                                                                  func Xshutdown(t *TLS, sockfd, how int32) int32

                                                                                                                                                                                                                                                                                                    int shutdown(int sockfd, int how);

                                                                                                                                                                                                                                                                                                    func Xsigaction

                                                                                                                                                                                                                                                                                                    func Xsigaction(t *TLS, signum int32, act, oldact uintptr) int32

                                                                                                                                                                                                                                                                                                      int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

                                                                                                                                                                                                                                                                                                      func Xsignal

                                                                                                                                                                                                                                                                                                      func Xsignal(t *TLS, signum int32, handler uintptr) uintptr

                                                                                                                                                                                                                                                                                                        sighandler_t signal(int signum, sighandler_t handler);

                                                                                                                                                                                                                                                                                                        func Xsin

                                                                                                                                                                                                                                                                                                        func Xsin(t *TLS, x float64) float64

                                                                                                                                                                                                                                                                                                        func Xsinf

                                                                                                                                                                                                                                                                                                        func Xsinf(t *TLS, x float32) float32

                                                                                                                                                                                                                                                                                                        func Xsinh

                                                                                                                                                                                                                                                                                                        func Xsinh(t *TLS, x float64) float64

                                                                                                                                                                                                                                                                                                        func Xsleep

                                                                                                                                                                                                                                                                                                        func Xsleep(t *TLS, seconds uint32) uint32

                                                                                                                                                                                                                                                                                                          unsigned int sleep(unsigned int seconds);

                                                                                                                                                                                                                                                                                                          func Xsnprintf

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

                                                                                                                                                                                                                                                                                                            int snprintf(char *str, size_t size, const char *format, ...);

                                                                                                                                                                                                                                                                                                            func Xsocket

                                                                                                                                                                                                                                                                                                            func Xsocket(t *TLS, domain, type1, protocol int32) int32

                                                                                                                                                                                                                                                                                                              int socket(int domain, int type, int protocol);

                                                                                                                                                                                                                                                                                                              func Xsprintf

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

                                                                                                                                                                                                                                                                                                                int sprintf(char *str, const char *format, ...);

                                                                                                                                                                                                                                                                                                                func Xsqrt

                                                                                                                                                                                                                                                                                                                func Xsqrt(t *TLS, x float64) float64

                                                                                                                                                                                                                                                                                                                func Xstat

                                                                                                                                                                                                                                                                                                                func Xstat(t *TLS, pathname, statbuf uintptr) int32

                                                                                                                                                                                                                                                                                                                  int stat(const char *pathname, struct stat *statbuf);

                                                                                                                                                                                                                                                                                                                  func Xstat64

                                                                                                                                                                                                                                                                                                                  func Xstat64(t *TLS, pathname, statbuf uintptr) int32

                                                                                                                                                                                                                                                                                                                    int stat(const char *pathname, struct stat *statbuf);

                                                                                                                                                                                                                                                                                                                    func Xstrcasecmp

                                                                                                                                                                                                                                                                                                                    func Xstrcasecmp(t *TLS, s1, s2 uintptr) int32

                                                                                                                                                                                                                                                                                                                      int strcasecmp(const char *s1, const char *s2);

                                                                                                                                                                                                                                                                                                                      func Xstrcat

                                                                                                                                                                                                                                                                                                                      func Xstrcat(t *TLS, dest, src uintptr) (r uintptr)

                                                                                                                                                                                                                                                                                                                        char *strcat(char *dest, const char *src)

                                                                                                                                                                                                                                                                                                                        func Xstrchr

                                                                                                                                                                                                                                                                                                                        func Xstrchr(t *TLS, s uintptr, c int32) uintptr

                                                                                                                                                                                                                                                                                                                          char *strchr(const char *s, int c)

                                                                                                                                                                                                                                                                                                                          func Xstrcmp

                                                                                                                                                                                                                                                                                                                          func Xstrcmp(t *TLS, s1, s2 uintptr) int32

                                                                                                                                                                                                                                                                                                                            int strcmp(const char *s1, const char *s2)

                                                                                                                                                                                                                                                                                                                            func Xstrcpy

                                                                                                                                                                                                                                                                                                                            func Xstrcpy(t *TLS, dest, src uintptr) (r uintptr)

                                                                                                                                                                                                                                                                                                                              char *strcpy(char *dest, const char *src)

                                                                                                                                                                                                                                                                                                                              func Xstrcspn

                                                                                                                                                                                                                                                                                                                              func Xstrcspn(t *TLS, s, reject uintptr) (r types.Size_t)

                                                                                                                                                                                                                                                                                                                                size_t strcspn(const char *s, const char *reject);

                                                                                                                                                                                                                                                                                                                                func Xstrdup

                                                                                                                                                                                                                                                                                                                                func Xstrdup(t *TLS, s uintptr) uintptr

                                                                                                                                                                                                                                                                                                                                  char *strdup(const char *s);

                                                                                                                                                                                                                                                                                                                                  func Xstrerror

                                                                                                                                                                                                                                                                                                                                  func Xstrerror(t *TLS, errnum int32) uintptr

                                                                                                                                                                                                                                                                                                                                    char *strerror(int errnum);

                                                                                                                                                                                                                                                                                                                                    func Xstrlen

                                                                                                                                                                                                                                                                                                                                    func Xstrlen(t *TLS, s uintptr) (r types.Size_t)

                                                                                                                                                                                                                                                                                                                                      size_t strlen(const char *s)

                                                                                                                                                                                                                                                                                                                                      func Xstrncmp

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

                                                                                                                                                                                                                                                                                                                                        int strncmp(const char *s1, const char *s2, size_t n)

                                                                                                                                                                                                                                                                                                                                        func Xstrncpy

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

                                                                                                                                                                                                                                                                                                                                          char *strncpy(char *dest, const char *src, size_t n)

                                                                                                                                                                                                                                                                                                                                          func Xstrpbrk

                                                                                                                                                                                                                                                                                                                                          func Xstrpbrk(t *TLS, s, accept uintptr) uintptr

                                                                                                                                                                                                                                                                                                                                            char *strpbrk(const char *s, const char *accept);

                                                                                                                                                                                                                                                                                                                                            func Xstrrchr

                                                                                                                                                                                                                                                                                                                                            func Xstrrchr(t *TLS, s uintptr, c int32) (r uintptr)

                                                                                                                                                                                                                                                                                                                                              char *strrchr(const char *s, int c)

                                                                                                                                                                                                                                                                                                                                              func Xstrstr

                                                                                                                                                                                                                                                                                                                                              func Xstrstr(t *TLS, haystack, needle uintptr) uintptr

                                                                                                                                                                                                                                                                                                                                                char *strstr(const char *haystack, const char *needle);

                                                                                                                                                                                                                                                                                                                                                func Xstrtol

                                                                                                                                                                                                                                                                                                                                                func Xstrtol(t *TLS, nptr, endptr uintptr, base int32) (r long)

                                                                                                                                                                                                                                                                                                                                                  long int strtol(const char *nptr, char **endptr, int base);

                                                                                                                                                                                                                                                                                                                                                  func Xstrtoul

                                                                                                                                                                                                                                                                                                                                                  func Xstrtoul(t *TLS, nptr, endptr uintptr, base int32) ulong

                                                                                                                                                                                                                                                                                                                                                    unsigned long int strtoul(const char *nptr, char **endptr, int base);

                                                                                                                                                                                                                                                                                                                                                    func Xsymlink(t *TLS, target, linkpath uintptr) int32

                                                                                                                                                                                                                                                                                                                                                      int symlink(const char *target, const char *linkpath);

                                                                                                                                                                                                                                                                                                                                                      func Xsysconf

                                                                                                                                                                                                                                                                                                                                                      func Xsysconf(t *TLS, name int32) long

                                                                                                                                                                                                                                                                                                                                                        long sysconf(int name);

                                                                                                                                                                                                                                                                                                                                                        func Xsystem

                                                                                                                                                                                                                                                                                                                                                        func Xsystem(t *TLS, command uintptr) int32

                                                                                                                                                                                                                                                                                                                                                          int system(const char *command);

                                                                                                                                                                                                                                                                                                                                                          func Xtan

                                                                                                                                                                                                                                                                                                                                                          func Xtan(t *TLS, x float64) float64

                                                                                                                                                                                                                                                                                                                                                          func Xtanh

                                                                                                                                                                                                                                                                                                                                                          func Xtanh(t *TLS, x float64) float64

                                                                                                                                                                                                                                                                                                                                                          func Xtcgetattr

                                                                                                                                                                                                                                                                                                                                                          func Xtcgetattr(t *TLS, fd int32, termios_p uintptr) int32

                                                                                                                                                                                                                                                                                                                                                            int tcgetattr(int fd, struct termios *termios_p);

                                                                                                                                                                                                                                                                                                                                                            func Xtcsetattr

                                                                                                                                                                                                                                                                                                                                                            func Xtcsetattr(t *TLS, fd, optional_actions int32, termios_p uintptr) int32

                                                                                                                                                                                                                                                                                                                                                              int tcsetattr(int fd, int optional_actions, const struct termios *termios_p);

                                                                                                                                                                                                                                                                                                                                                              func Xtime

                                                                                                                                                                                                                                                                                                                                                              func Xtime(t *TLS, tloc uintptr) types.Time_t

                                                                                                                                                                                                                                                                                                                                                                time_t time(time_t *tloc);

                                                                                                                                                                                                                                                                                                                                                                func Xtolower

                                                                                                                                                                                                                                                                                                                                                                func Xtolower(t *TLS, c int32) int32

                                                                                                                                                                                                                                                                                                                                                                  int tolower(int c);

                                                                                                                                                                                                                                                                                                                                                                  func Xtoupper

                                                                                                                                                                                                                                                                                                                                                                  func Xtoupper(t *TLS, c int32) int32

                                                                                                                                                                                                                                                                                                                                                                    int toupper(int c);

                                                                                                                                                                                                                                                                                                                                                                    func Xtzset

                                                                                                                                                                                                                                                                                                                                                                    func Xtzset(t *TLS)

                                                                                                                                                                                                                                                                                                                                                                    func Xumask

                                                                                                                                                                                                                                                                                                                                                                    func Xumask(t *TLS, mask types.Mode_t) types.Mode_t

                                                                                                                                                                                                                                                                                                                                                                      mode_t umask(mode_t mask);

                                                                                                                                                                                                                                                                                                                                                                      func Xuname

                                                                                                                                                                                                                                                                                                                                                                      func Xuname(t *TLS, buf uintptr) int32

                                                                                                                                                                                                                                                                                                                                                                        int uname(struct utsname *buf);

                                                                                                                                                                                                                                                                                                                                                                        func Xunlink(t *TLS, pathname uintptr) int32

                                                                                                                                                                                                                                                                                                                                                                          int unlink(const char *pathname);

                                                                                                                                                                                                                                                                                                                                                                          func Xusleep

                                                                                                                                                                                                                                                                                                                                                                          func Xusleep(t *TLS, usec types.X__useconds_t) int32

                                                                                                                                                                                                                                                                                                                                                                            int usleep(useconds_t usec);

                                                                                                                                                                                                                                                                                                                                                                            func Xutime

                                                                                                                                                                                                                                                                                                                                                                            func Xutime(t *TLS, filename, times uintptr) int32

                                                                                                                                                                                                                                                                                                                                                                              int utime(const char *filename, const struct utimbuf *times);

                                                                                                                                                                                                                                                                                                                                                                              func Xutimes

                                                                                                                                                                                                                                                                                                                                                                              func Xutimes(t *TLS, filename, times uintptr) int32

                                                                                                                                                                                                                                                                                                                                                                                int utimes(const char *filename, const struct timeval times[2]);

                                                                                                                                                                                                                                                                                                                                                                                func Xvfprintf

                                                                                                                                                                                                                                                                                                                                                                                func Xvfprintf(t *TLS, stream, format, ap uintptr) int32

                                                                                                                                                                                                                                                                                                                                                                                func Xvprintf

                                                                                                                                                                                                                                                                                                                                                                                func Xvprintf(t *TLS, s, ap uintptr) int32

                                                                                                                                                                                                                                                                                                                                                                                  int vprintf(const char *format, va_list ap);

                                                                                                                                                                                                                                                                                                                                                                                  func Xwaitpid

                                                                                                                                                                                                                                                                                                                                                                                  func Xwaitpid(t *TLS, pid types.Pid_t, wstatus uintptr, optname int32) types.Pid_t

                                                                                                                                                                                                                                                                                                                                                                                    pid_t waitpid(pid_t pid, int *wstatus, int options);

                                                                                                                                                                                                                                                                                                                                                                                    func Xwrite

                                                                                                                                                                                                                                                                                                                                                                                    func Xwrite(t *TLS, fd int32, buf uintptr, count types.Size_t) types.Ssize_t

                                                                                                                                                                                                                                                                                                                                                                                      ssize_t write(int fd, const void *buf, size_t count);

                                                                                                                                                                                                                                                                                                                                                                                      Types

                                                                                                                                                                                                                                                                                                                                                                                      type RawMem

                                                                                                                                                                                                                                                                                                                                                                                      type RawMem [1<<50 - 1]byte

                                                                                                                                                                                                                                                                                                                                                                                      type TLS

                                                                                                                                                                                                                                                                                                                                                                                      type TLS struct {
                                                                                                                                                                                                                                                                                                                                                                                      	ID int32
                                                                                                                                                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                      func NewTLS

                                                                                                                                                                                                                                                                                                                                                                                      func NewTLS() *TLS

                                                                                                                                                                                                                                                                                                                                                                                      func (*TLS) Alloc

                                                                                                                                                                                                                                                                                                                                                                                      func (t *TLS) Alloc(n int) (r uintptr)

                                                                                                                                                                                                                                                                                                                                                                                      func (*TLS) Close

                                                                                                                                                                                                                                                                                                                                                                                      func (t *TLS) Close()

                                                                                                                                                                                                                                                                                                                                                                                      func (*TLS) Free

                                                                                                                                                                                                                                                                                                                                                                                      func (t *TLS) Free(n int)

                                                                                                                                                                                                                                                                                                                                                                                      Directories

                                                                                                                                                                                                                                                                                                                                                                                      Path Synopsis
                                                                                                                                                                                                                                                                                                                                                                                      netinet
                                                                                                                                                                                                                                                                                                                                                                                      in
                                                                                                                                                                                                                                                                                                                                                                                      sys