libc

package module
v0.0.6 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 18, 2023 License: BSD-3-Clause Imports: 55 Imported by: 5

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.

Index

Constants

View Source 
const (
	DT_EXITING  = 0
	DT_JOINABLE = 1
	DT_DETACHED = 2
)

Variables

View Source 
var (
	Covered  = map[uintptr]struct{}{}
	CoveredC = map[string]struct{}{}
)
View Source 
var CAPI = map[string]struct{}{}/* 521 elements not displayed */
View Source 
var X__fsmu8 = [51]uint32_t{
	func() uint32 {
		if 0x2 < 2 {
			return Uint32FromInt32(-1)
		}
		return func() uint32 {
			if Int32(0x80) == Int32(0x80) {
				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
			}
			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
		}()<<23 | uint32_t(0x2)
	}(), func() uint32 {
		if 0x3 < 2 {
			return Uint32FromInt32(-1)
		}
		return func() uint32 {
			if Int32(0x80) == Int32(0x80) {
				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
			}
			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
		}()<<23 | uint32_t(0x3)
	}(), func() uint32 {
		if 0x4 < 2 {
			return Uint32FromInt32(-1)
		}
		return func() uint32 {
			if Int32(0x80) == Int32(0x80) {
				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
			}
			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
		}()<<23 | uint32_t(0x4)
	}(), func() uint32 {
		if 0x5 < 2 {
			return Uint32FromInt32(-1)
		}
		return func() uint32 {
			if Int32(0x80) == Int32(0x80) {
				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
			}
			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
		}()<<23 | uint32_t(0x5)
	}(), func() uint32 {
		if 0x6 < 2 {
			return Uint32FromInt32(-1)
		}
		return func() uint32 {
			if Int32(0x80) == Int32(0x80) {
				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
			}
			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
		}()<<23 | uint32_t(0x6)
	}(), func() uint32 {
		if 0x7 < 2 {
			return Uint32FromInt32(-1)
		}
		return func() uint32 {
			if Int32(0x80) == Int32(0x80) {
				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
			}
			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
		}()<<23 | uint32_t(0x7)
	}(),
	func() uint32 {
		if 0x8 < 2 {
			return Uint32FromInt32(-1)
		}
		return func() uint32 {
			if Int32(0x80) == Int32(0x80) {
				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
			}
			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
		}()<<23 | uint32_t(0x8)
	}(), func() uint32 {
		if 0x9 < 2 {
			return Uint32FromInt32(-1)
		}
		return func() uint32 {
			if Int32(0x80) == Int32(0x80) {
				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
			}
			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
		}()<<23 | uint32_t(0x9)
	}(), func() uint32 {
		if 0xa < 2 {
			return Uint32FromInt32(-1)
		}
		return func() uint32 {
			if Int32(0x80) == Int32(0x80) {
				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
			}
			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
		}()<<23 | uint32_t(0xa)
	}(), func() uint32 {
		if 0xb < 2 {
			return Uint32FromInt32(-1)
		}
		return func() uint32 {
			if Int32(0x80) == Int32(0x80) {
				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
			}
			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
		}()<<23 | uint32_t(0xb)
	}(), func() uint32 {
		if 0xc < 2 {
			return Uint32FromInt32(-1)
		}
		return func() uint32 {
			if Int32(0x80) == Int32(0x80) {
				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
			}
			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
		}()<<23 | uint32_t(0xc)
	}(), func() uint32 {
		if 0xd < 2 {
			return Uint32FromInt32(-1)
		}
		return func() uint32 {
			if Int32(0x80) == Int32(0x80) {
				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
			}
			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
		}()<<23 | uint32_t(0xd)
	}(), func() uint32 {
		if 0xe < 2 {
			return Uint32FromInt32(-1)
		}
		return func() uint32 {
			if Int32(0x80) == Int32(0x80) {
				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
			}
			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
		}()<<23 | uint32_t(0xe)
	}(), func() uint32 {
		if 0xf < 2 {
			return Uint32FromInt32(-1)
		}
		return func() uint32 {
			if Int32(0x80) == Int32(0x80) {
				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
			}
			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
		}()<<23 | uint32_t(0xf)
	}(),
	func() uint32 {
		if 0x0+16 < 2 {
			return Uint32FromInt32(-1)
		}
		return func() uint32 {
			if Int32(0x80) == Int32(0x80) {
				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
			}
			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
		}()<<23 | uint32_t(0x0+16)
	}(), func() uint32 {
		if 0x1+16 < 2 {
			return Uint32FromInt32(-1)
		}
		return func() uint32 {
			if Int32(0x80) == Int32(0x80) {
				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
			}
			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
		}()<<23 | uint32_t(0x1+16)
	}(), func() uint32 {
		if 0x2+16 < 2 {
			return Uint32FromInt32(-1)
		}
		return func() uint32 {
			if Int32(0x80) == Int32(0x80) {
				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
			}
			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
		}()<<23 | uint32_t(0x2+16)
	}(), func() uint32 {
		if 0x3+16 < 2 {
			return Uint32FromInt32(-1)
		}
		return func() uint32 {
			if Int32(0x80) == Int32(0x80) {
				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
			}
			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
		}()<<23 | uint32_t(0x3+16)
	}(), func() uint32 {
		if 0x4+16 < 2 {
			return Uint32FromInt32(-1)
		}
		return func() uint32 {
			if Int32(0x80) == Int32(0x80) {
				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
			}
			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
		}()<<23 | uint32_t(0x4+16)
	}(), func() uint32 {
		if 0x5+16 < 2 {
			return Uint32FromInt32(-1)
		}
		return func() uint32 {
			if Int32(0x80) == Int32(0x80) {
				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
			}
			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
		}()<<23 | uint32_t(0x5+16)
	}(), func() uint32 {
		if 0x6+16 < 2 {
			return Uint32FromInt32(-1)
		}
		return func() uint32 {
			if Int32(0x80) == Int32(0x80) {
				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
			}
			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
		}()<<23 | uint32_t(0x6+16)
	}(), func() uint32 {
		if 0x7+16 < 2 {
			return Uint32FromInt32(-1)
		}
		return func() uint32 {
			if Int32(0x80) == Int32(0x80) {
				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
			}
			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
		}()<<23 | uint32_t(0x7+16)
	}(),
	func() uint32 {
		if 0x8+16 < 2 {
			return Uint32FromInt32(-1)
		}
		return func() uint32 {
			if Int32(0x80) == Int32(0x80) {
				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
			}
			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
		}()<<23 | uint32_t(0x8+16)
	}(), func() uint32 {
		if 0x9+16 < 2 {
			return Uint32FromInt32(-1)
		}
		return func() uint32 {
			if Int32(0x80) == Int32(0x80) {
				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
			}
			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
		}()<<23 | uint32_t(0x9+16)
	}(), func() uint32 {
		if 0xa+16 < 2 {
			return Uint32FromInt32(-1)
		}
		return func() uint32 {
			if Int32(0x80) == Int32(0x80) {
				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
			}
			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
		}()<<23 | uint32_t(0xa+16)
	}(), func() uint32 {
		if 0xb+16 < 2 {
			return Uint32FromInt32(-1)
		}
		return func() uint32 {
			if Int32(0x80) == Int32(0x80) {
				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
			}
			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
		}()<<23 | uint32_t(0xb+16)
	}(), func() uint32 {
		if 0xc+16 < 2 {
			return Uint32FromInt32(-1)
		}
		return func() uint32 {
			if Int32(0x80) == Int32(0x80) {
				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
			}
			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
		}()<<23 | uint32_t(0xc+16)
	}(), func() uint32 {
		if 0xd+16 < 2 {
			return Uint32FromInt32(-1)
		}
		return func() uint32 {
			if Int32(0x80) == Int32(0x80) {
				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
			}
			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
		}()<<23 | uint32_t(0xd+16)
	}(), func() uint32 {
		if 0xe+16 < 2 {
			return Uint32FromInt32(-1)
		}
		return func() uint32 {
			if Int32(0x80) == Int32(0x80) {
				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
			}
			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
		}()<<23 | uint32_t(0xe+16)
	}(), func() uint32 {
		if 0xf+16 < 2 {
			return Uint32FromInt32(-1)
		}
		return func() uint32 {
			if Int32(0x80) == Int32(0x80) {
				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
			}
			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
		}()<<23 | uint32_t(0xf+16)
	}(),
	func() uint32 {
		if 0x0 == 0 {
			return func() uint32 {
				if Int32(0xa0) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
			}() << 23
		}
		return func() uint32 {
			if 0x0 == 0xd {
				return func() uint32 {
					if Int32(0x80) == Int32(0x80) {
						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
					}
					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
				}() << 23
			}
			return func() uint32 {
				if Int32(0x80) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
			}() << 23
		}()
	}() | uint32_t(func() uint32 {
		if Int32(0x80) == Int32(0x80) {
			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
		}
		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
	}()<<23)>>6 | uint32_t(0x0), func() uint32 {
		if 0x1 == 0 {
			return func() uint32 {
				if Int32(0xa0) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
			}() << 23
		}
		return func() uint32 {
			if 0x1 == 0xd {
				return func() uint32 {
					if Int32(0x80) == Int32(0x80) {
						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
					}
					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
				}() << 23
			}
			return func() uint32 {
				if Int32(0x80) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
			}() << 23
		}()
	}() | uint32_t(func() uint32 {
		if Int32(0x80) == Int32(0x80) {
			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
		}
		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
	}()<<23)>>6 | uint32_t(0x1), func() uint32 {
		if 0x2 == 0 {
			return func() uint32 {
				if Int32(0xa0) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
			}() << 23
		}
		return func() uint32 {
			if 0x2 == 0xd {
				return func() uint32 {
					if Int32(0x80) == Int32(0x80) {
						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
					}
					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
				}() << 23
			}
			return func() uint32 {
				if Int32(0x80) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
			}() << 23
		}()
	}() | uint32_t(func() uint32 {
		if Int32(0x80) == Int32(0x80) {
			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
		}
		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
	}()<<23)>>6 | uint32_t(0x2), func() uint32 {
		if 0x3 == 0 {
			return func() uint32 {
				if Int32(0xa0) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
			}() << 23
		}
		return func() uint32 {
			if 0x3 == 0xd {
				return func() uint32 {
					if Int32(0x80) == Int32(0x80) {
						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
					}
					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
				}() << 23
			}
			return func() uint32 {
				if Int32(0x80) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
			}() << 23
		}()
	}() | uint32_t(func() uint32 {
		if Int32(0x80) == Int32(0x80) {
			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
		}
		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
	}()<<23)>>6 | uint32_t(0x3), func() uint32 {
		if 0x4 == 0 {
			return func() uint32 {
				if Int32(0xa0) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
			}() << 23
		}
		return func() uint32 {
			if 0x4 == 0xd {
				return func() uint32 {
					if Int32(0x80) == Int32(0x80) {
						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
					}
					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
				}() << 23
			}
			return func() uint32 {
				if Int32(0x80) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
			}() << 23
		}()
	}() | uint32_t(func() uint32 {
		if Int32(0x80) == Int32(0x80) {
			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
		}
		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
	}()<<23)>>6 | uint32_t(0x4), func() uint32 {
		if 0x5 == 0 {
			return func() uint32 {
				if Int32(0xa0) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
			}() << 23
		}
		return func() uint32 {
			if 0x5 == 0xd {
				return func() uint32 {
					if Int32(0x80) == Int32(0x80) {
						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
					}
					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
				}() << 23
			}
			return func() uint32 {
				if Int32(0x80) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
			}() << 23
		}()
	}() | uint32_t(func() uint32 {
		if Int32(0x80) == Int32(0x80) {
			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
		}
		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
	}()<<23)>>6 | uint32_t(0x5), func() uint32 {
		if 0x6 == 0 {
			return func() uint32 {
				if Int32(0xa0) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
			}() << 23
		}
		return func() uint32 {
			if 0x6 == 0xd {
				return func() uint32 {
					if Int32(0x80) == Int32(0x80) {
						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
					}
					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
				}() << 23
			}
			return func() uint32 {
				if Int32(0x80) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
			}() << 23
		}()
	}() | uint32_t(func() uint32 {
		if Int32(0x80) == Int32(0x80) {
			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
		}
		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
	}()<<23)>>6 | uint32_t(0x6), func() uint32 {
		if 0x7 == 0 {
			return func() uint32 {
				if Int32(0xa0) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
			}() << 23
		}
		return func() uint32 {
			if 0x7 == 0xd {
				return func() uint32 {
					if Int32(0x80) == Int32(0x80) {
						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
					}
					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
				}() << 23
			}
			return func() uint32 {
				if Int32(0x80) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
			}() << 23
		}()
	}() | uint32_t(func() uint32 {
		if Int32(0x80) == Int32(0x80) {
			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
		}
		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
	}()<<23)>>6 | uint32_t(0x7),
	func() uint32 {
		if 0x8 == 0 {
			return func() uint32 {
				if Int32(0xa0) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
			}() << 23
		}
		return func() uint32 {
			if 0x8 == 0xd {
				return func() uint32 {
					if Int32(0x80) == Int32(0x80) {
						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
					}
					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
				}() << 23
			}
			return func() uint32 {
				if Int32(0x80) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
			}() << 23
		}()
	}() | uint32_t(func() uint32 {
		if Int32(0x80) == Int32(0x80) {
			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
		}
		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
	}()<<23)>>6 | uint32_t(0x8), func() uint32 {
		if 0x9 == 0 {
			return func() uint32 {
				if Int32(0xa0) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
			}() << 23
		}
		return func() uint32 {
			if 0x9 == 0xd {
				return func() uint32 {
					if Int32(0x80) == Int32(0x80) {
						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
					}
					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
				}() << 23
			}
			return func() uint32 {
				if Int32(0x80) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
			}() << 23
		}()
	}() | uint32_t(func() uint32 {
		if Int32(0x80) == Int32(0x80) {
			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
		}
		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
	}()<<23)>>6 | uint32_t(0x9), func() uint32 {
		if 0xa == 0 {
			return func() uint32 {
				if Int32(0xa0) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
			}() << 23
		}
		return func() uint32 {
			if 0xa == 0xd {
				return func() uint32 {
					if Int32(0x80) == Int32(0x80) {
						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
					}
					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
				}() << 23
			}
			return func() uint32 {
				if Int32(0x80) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
			}() << 23
		}()
	}() | uint32_t(func() uint32 {
		if Int32(0x80) == Int32(0x80) {
			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
		}
		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
	}()<<23)>>6 | uint32_t(0xa), func() uint32 {
		if 0xb == 0 {
			return func() uint32 {
				if Int32(0xa0) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
			}() << 23
		}
		return func() uint32 {
			if 0xb == 0xd {
				return func() uint32 {
					if Int32(0x80) == Int32(0x80) {
						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
					}
					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
				}() << 23
			}
			return func() uint32 {
				if Int32(0x80) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
			}() << 23
		}()
	}() | uint32_t(func() uint32 {
		if Int32(0x80) == Int32(0x80) {
			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
		}
		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
	}()<<23)>>6 | uint32_t(0xb), func() uint32 {
		if 0xc == 0 {
			return func() uint32 {
				if Int32(0xa0) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
			}() << 23
		}
		return func() uint32 {
			if 0xc == 0xd {
				return func() uint32 {
					if Int32(0x80) == Int32(0x80) {
						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
					}
					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
				}() << 23
			}
			return func() uint32 {
				if Int32(0x80) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
			}() << 23
		}()
	}() | uint32_t(func() uint32 {
		if Int32(0x80) == Int32(0x80) {
			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
		}
		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
	}()<<23)>>6 | uint32_t(0xc), func() uint32 {
		if 0xd == 0 {
			return func() uint32 {
				if Int32(0xa0) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
			}() << 23
		}
		return func() uint32 {
			if 0xd == 0xd {
				return func() uint32 {
					if Int32(0x80) == Int32(0x80) {
						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
					}
					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
				}() << 23
			}
			return func() uint32 {
				if Int32(0x80) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
			}() << 23
		}()
	}() | uint32_t(func() uint32 {
		if Int32(0x80) == Int32(0x80) {
			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
		}
		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
	}()<<23)>>6 | uint32_t(0xd), func() uint32 {
		if 0xe == 0 {
			return func() uint32 {
				if Int32(0xa0) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
			}() << 23
		}
		return func() uint32 {
			if 0xe == 0xd {
				return func() uint32 {
					if Int32(0x80) == Int32(0x80) {
						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
					}
					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
				}() << 23
			}
			return func() uint32 {
				if Int32(0x80) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
			}() << 23
		}()
	}() | uint32_t(func() uint32 {
		if Int32(0x80) == Int32(0x80) {
			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
		}
		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
	}()<<23)>>6 | uint32_t(0xe), func() uint32 {
		if 0xf == 0 {
			return func() uint32 {
				if Int32(0xa0) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
			}() << 23
		}
		return func() uint32 {
			if 0xf == 0xd {
				return func() uint32 {
					if Int32(0x80) == Int32(0x80) {
						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
					}
					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
				}() << 23
			}
			return func() uint32 {
				if Int32(0x80) == Int32(0x80) {
					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
				}
				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
			}() << 23
		}()
	}() | uint32_t(func() uint32 {
		if Int32(0x80) == Int32(0x80) {
			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
		}
		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
	}()<<23)>>6 | uint32_t(0xf),
	func() uint32 {
		if 0x0 >= 5 {
			return uint32(0)
		}
		return func() uint32 {
			if 0x0 == 0 {
				return func() uint32 {
					if Int32(0x90) == Int32(0x80) {
						return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
					}
					return Uint32(Uint32(0) - Uint32FromInt32(0x90))
				}() << 23
			}
			return func() uint32 {
				if 0x0 == 4 {
					return func() uint32 {
						if Int32(0x80) == Int32(0x80) {
							return Uint32(Uint32(0x40) - Uint32FromInt32(0x90))
						}
						return Uint32(Uint32(0) - Uint32FromInt32(0x80))
					}() << 23
				}
				return func() uint32 {
					if Int32(0x80) == Int32(0x80) {
						return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
					}
					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
				}() << 23
			}()
		}()
	}() | uint32_t(func() uint32 {
		if Int32(0x80) == Int32(0x80) {
			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
		}
		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
	}()<<23)>>6 | uint32_t(func() uint32 {
		if Int32(0x80) == Int32(0x80) {
			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
		}
		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
	}()<<23)>>12 | uint32_t(0x0), func() uint32 {
		if 0x1 >= 5 {
			return uint32(0)
		}
		return func() uint32 {
			if 0x1 == 0 {
				return func() uint32 {
					if Int32(0x90) == Int32(0x80) {
						return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
					}
					return Uint32(Uint32(0) - Uint32FromInt32(0x90))
				}() << 23
			}
			return func() uint32 {
				if 0x1 == 4 {
					return func() uint32 {
						if Int32(0x80) == Int32(0x80) {
							return Uint32(Uint32(0x40) - Uint32FromInt32(0x90))
						}
						return Uint32(Uint32(0) - Uint32FromInt32(0x80))
					}() << 23
				}
				return func() uint32 {
					if Int32(0x80) == Int32(0x80) {
						return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
					}
					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
				}() << 23
			}()
		}()
	}() | uint32_t(func() uint32 {
		if Int32(0x80) == Int32(0x80) {
			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
		}
		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
	}()<<23)>>6 | uint32_t(func() uint32 {
		if Int32(0x80) == Int32(0x80) {
			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
		}
		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
	}()<<23)>>12 | uint32_t(0x1), func() uint32 {
		if 0x2 >= 5 {
			return uint32(0)
		}
		return func() uint32 {
			if 0x2 == 0 {
				return func() uint32 {
					if Int32(0x90) == Int32(0x80) {
						return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
					}
					return Uint32(Uint32(0) - Uint32FromInt32(0x90))
				}() << 23
			}
			return func() uint32 {
				if 0x2 == 4 {
					return func() uint32 {
						if Int32(0x80) == Int32(0x80) {
							return Uint32(Uint32(0x40) - Uint32FromInt32(0x90))
						}
						return Uint32(Uint32(0) - Uint32FromInt32(0x80))
					}() << 23
				}
				return func() uint32 {
					if Int32(0x80) == Int32(0x80) {
						return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
					}
					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
				}() << 23
			}()
		}()
	}() | uint32_t(func() uint32 {
		if Int32(0x80) == Int32(0x80) {
			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
		}
		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
	}()<<23)>>6 | uint32_t(func() uint32 {
		if Int32(0x80) == Int32(0x80) {
			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
		}
		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
	}()<<23)>>12 | uint32_t(0x2), func() uint32 {
		if 0x3 >= 5 {
			return uint32(0)
		}
		return func() uint32 {
			if 0x3 == 0 {
				return func() uint32 {
					if Int32(0x90) == Int32(0x80) {
						return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
					}
					return Uint32(Uint32(0) - Uint32FromInt32(0x90))
				}() << 23
			}
			return func() uint32 {
				if 0x3 == 4 {
					return func() uint32 {
						if Int32(0x80) == Int32(0x80) {
							return Uint32(Uint32(0x40) - Uint32FromInt32(0x90))
						}
						return Uint32(Uint32(0) - Uint32FromInt32(0x80))
					}() << 23
				}
				return func() uint32 {
					if Int32(0x80) == Int32(0x80) {
						return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
					}
					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
				}() << 23
			}()
		}()
	}() | uint32_t(func() uint32 {
		if Int32(0x80) == Int32(0x80) {
			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
		}
		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
	}()<<23)>>6 | uint32_t(func() uint32 {
		if Int32(0x80) == Int32(0x80) {
			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
		}
		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
	}()<<23)>>12 | uint32_t(0x3), func() uint32 {
		if 0x4 >= 5 {
			return uint32(0)
		}
		return func() uint32 {
			if 0x4 == 0 {
				return func() uint32 {
					if Int32(0x90) == Int32(0x80) {
						return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
					}
					return Uint32(Uint32(0) - Uint32FromInt32(0x90))
				}() << 23
			}
			return func() uint32 {
				if 0x4 == 4 {
					return func() uint32 {
						if Int32(0x80) == Int32(0x80) {
							return Uint32(Uint32(0x40) - Uint32FromInt32(0x90))
						}
						return Uint32(Uint32(0) - Uint32FromInt32(0x80))
					}() << 23
				}
				return func() uint32 {
					if Int32(0x80) == Int32(0x80) {
						return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
					}
					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
				}() << 23
			}()
		}()
	}() | uint32_t(func() uint32 {
		if Int32(0x80) == Int32(0x80) {
			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
		}
		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
	}()<<23)>>6 | uint32_t(func() uint32 {
		if Int32(0x80) == Int32(0x80) {
			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
		}
		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
	}()<<23)>>12 | uint32_t(0x4),

} /* internal.c:18:16 */
View Source 
var Xenviron uintptr

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

View Source 
var Xh_errno int32 /* h_errno.c:4:5: */
View Source 
var Xstderr = newFile(nil, unistd.STDERR_FILENO)
View Source 
var Xstdin = newFile(nil, unistd.STDIN_FILENO)
View Source 
var Xstdout = newFile(nil, unistd.STDOUT_FILENO)
View Source 
var Xzero_struct_address address /* lookup_name.c:27:16: */

Functions

func AssignAddComplex128 

func AssignAddComplex128(p *complex128, v complex128) complex128

func AssignAddComplex64 

func AssignAddComplex64(p *complex64, v complex64) complex64

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 AssignAddPtrComplex128 

func AssignAddPtrComplex128(p uintptr, v complex128) complex128

func AssignAddPtrComplex64 

func AssignAddPtrComplex64(p uintptr, v complex64) complex64

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 AssignComplex128 

func AssignComplex128(p *complex128, v complex128) complex128

func AssignComplex64 

func AssignComplex64(p *complex64, v complex64) complex64

func AssignDivComplex128 

func AssignDivComplex128(p *complex128, v complex128) complex128

func AssignDivComplex64 

func AssignDivComplex64(p *complex64, v complex64) complex64

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 AssignDivPtrComplex128 

func AssignDivPtrComplex128(p uintptr, v complex128) complex128

func AssignDivPtrComplex64 

func AssignDivPtrComplex64(p uintptr, v complex64) complex64

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 AssignMulComplex128 

func AssignMulComplex128(p *complex128, v complex128) complex128

func AssignMulComplex64 

func AssignMulComplex64(p *complex64, v complex64) complex64

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 AssignMulPtrComplex128 

func AssignMulPtrComplex128(p uintptr, v complex128) complex128

func AssignMulPtrComplex64 

func AssignMulPtrComplex64(p uintptr, v complex64) complex64

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 AssignPtrComplex128 

func AssignPtrComplex128(p uintptr, v complex128) complex128

func AssignPtrComplex64 

func AssignPtrComplex64(p uintptr, v complex64) complex64

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 AssignSubComplex128 

func AssignSubComplex128(p *complex128, v complex128) complex128

func AssignSubComplex64 

func AssignSubComplex64(p *complex64, v complex64) complex64

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 AssignSubPtrComplex128 

func AssignSubPtrComplex128(p uintptr, v complex128) complex128

func AssignSubPtrComplex64 

func AssignSubPtrComplex64(p uintptr, v complex64) complex64

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 AtExit 

func AtExit(f func())

AtExit will attempt to run f at process exit. The execution cannot be guaranteed, neither its ordering with respect to any other handlers registered by AtExit.

func AtomicAddFloat32 

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

func AtomicAddFloat64 

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

func AtomicAddInt32 

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

func AtomicAddInt64 

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

func AtomicAddUint32 

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

func AtomicAddUint64 

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

func AtomicAddUintptr 

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

func AtomicLoadFloat32 

func AtomicLoadFloat32(addr *float32) (val float32)

func AtomicLoadFloat64 

func AtomicLoadFloat64(addr *float64) (val float64)

func AtomicLoadInt32 

func AtomicLoadInt32(addr *int32) (val int32)

func AtomicLoadInt64 

func AtomicLoadInt64(addr *int64) (val int64)

func AtomicLoadNInt32 

func AtomicLoadNInt32(ptr uintptr, memorder int32) int32

func AtomicLoadNInt64 

func AtomicLoadNInt64(ptr uintptr, memorder int32) int64

func AtomicLoadNUint16 

func AtomicLoadNUint16(ptr uintptr, memorder int32) uint16

func AtomicLoadNUint32 

func AtomicLoadNUint32(ptr uintptr, memorder int32) uint32

func AtomicLoadNUint64 

func AtomicLoadNUint64(ptr uintptr, memorder int32) uint64

func AtomicLoadNUintptr 

func AtomicLoadNUintptr(ptr uintptr, memorder int32) uintptr

func AtomicLoadPFloat32 

func AtomicLoadPFloat32(addr uintptr) (val float32)

func AtomicLoadPFloat64 

func AtomicLoadPFloat64(addr uintptr) (val float64)

func AtomicLoadPInt32 

func AtomicLoadPInt32(addr uintptr) (val int32)

func AtomicLoadPInt64 

func AtomicLoadPInt64(addr uintptr) (val int64)

func AtomicLoadPUint32 

func AtomicLoadPUint32(addr uintptr) (val uint32)

func AtomicLoadPUint64 

func AtomicLoadPUint64(addr uintptr) (val uint64)

func AtomicLoadPUintptr 

func AtomicLoadPUintptr(addr uintptr) (val uintptr)

func AtomicLoadUint32 

func AtomicLoadUint32(addr *uint32) (val uint32)

func AtomicLoadUint64 

func AtomicLoadUint64(addr *uint64) (val uint64)

func AtomicLoadUintptr 

func AtomicLoadUintptr(addr *uintptr) (val uintptr)

func AtomicStoreFloat32 

func AtomicStoreFloat32(addr *float32, val float32)

func AtomicStoreFloat64 

func AtomicStoreFloat64(addr *float64, val float64)

func AtomicStoreInt32 

func AtomicStoreInt32(addr *int32, val int32)

func AtomicStoreInt64 

func AtomicStoreInt64(addr *int64, val int64)

func AtomicStoreNInt32 

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

func AtomicStoreNInt64 

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

func AtomicStoreNUint16 

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

func AtomicStoreNUint32 

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

func AtomicStoreNUint64 

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

func AtomicStoreNUintptr 

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

func AtomicStorePFloat32 

func AtomicStorePFloat32(addr uintptr, val float32)

func AtomicStorePFloat64 

func AtomicStorePFloat64(addr uintptr, val float64)

func AtomicStorePInt32 

func AtomicStorePInt32(addr uintptr, val int32)

func AtomicStorePInt64 

func AtomicStorePInt64(addr uintptr, val int64)

func AtomicStorePUint32 

func AtomicStorePUint32(addr uintptr, val uint32)

func AtomicStorePUint64 

func AtomicStorePUint64(addr uintptr, val uint64)

func AtomicStorePUintptr 

func AtomicStorePUintptr(addr uintptr, val uintptr)

func AtomicStoreUint32 

func AtomicStoreUint32(addr *uint32, val uint32)

func AtomicStoreUint64 

func AtomicStoreUint64(addr *uint64, val uint64)

func AtomicStoreUintptr 

func AtomicStoreUintptr(addr *uintptr, val 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 BoolUintptr 

func BoolUintptr(b bool) uintptr

func CString 

func CString(s string) (uintptr, error)

func Complex128 

func Complex128(n complex128) complex128

func Complex128FromComplex128 

func Complex128FromComplex128(n complex128) complex128

func Complex128FromComplex64 

func Complex128FromComplex64(n complex64) complex128

func Complex128FromFloat32 

func Complex128FromFloat32(n float32) complex128

func Complex128FromFloat64 

func Complex128FromFloat64(n float64) complex128

func Complex128FromInt16 

func Complex128FromInt16(n int16) complex128

func Complex128FromInt32 

func Complex128FromInt32(n int32) complex128

func Complex128FromInt64 

func Complex128FromInt64(n int64) complex128

func Complex128FromInt8 

func Complex128FromInt8(n int8) complex128

func Complex128FromUint16 

func Complex128FromUint16(n uint16) complex128

func Complex128FromUint32 

func Complex128FromUint32(n uint32) complex128

func Complex128FromUint64 

func Complex128FromUint64(n uint64) complex128

func Complex128FromUint8 

func Complex128FromUint8(n uint8) complex128

func Complex128FromUintptr 

func Complex128FromUintptr(n uintptr) complex128

func Complex64 

func Complex64(n complex64) complex64

func Complex64FromComplex128 

func Complex64FromComplex128(n complex128) complex64

func Complex64FromComplex64 

func Complex64FromComplex64(n complex64) complex64

func Complex64FromFloat32 

func Complex64FromFloat32(n float32) complex64

func Complex64FromFloat64 

func Complex64FromFloat64(n float64) complex64

func Complex64FromInt16 

func Complex64FromInt16(n int16) complex64

func Complex64FromInt32 

func Complex64FromInt32(n int32) complex64

func Complex64FromInt64 

func Complex64FromInt64(n int64) complex64

func Complex64FromInt8 

func Complex64FromInt8(n int8) complex64

func Complex64FromUint16 

func Complex64FromUint16(n uint16) complex64

func Complex64FromUint32 

func Complex64FromUint32(n uint32) complex64

func Complex64FromUint64 

func Complex64FromUint64(n uint64) complex64

func Complex64FromUint8 

func Complex64FromUint8(n uint8) complex64

func Complex64FromUintptr 

func Complex64FromUintptr(n uintptr) complex64

func Cover 

func Cover()

func CoverC 

func CoverC(s string)

func CoverCReport 

func CoverCReport(w io.Writer) error

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 Dmesg 

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

func Environ 

func Environ() uintptr

func EnvironP 

func EnvironP() uintptr

func Float32 

func Float32(n float32) float32

func Float32FromComplex128 

func Float32FromComplex128(n complex128) float32

func Float32FromComplex64 

func Float32FromComplex64(n complex64) 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 Float64FromComplex128 

func Float64FromComplex128(n complex128) float64

func Float64FromComplex64 

func Float64FromComplex64(n complex64) 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 GoBytes 

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

GoBytes returns a byte slice from a C char* having length len bytes.

func GoString 

func GoString(s uintptr) string

func Int16 

func Int16(n int16) int16

func Int16FromComplex128 

func Int16FromComplex128(n complex128) int16

func Int16FromComplex64 

func Int16FromComplex64(n complex64) 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 Int32FromComplex128 

func Int32FromComplex128(n complex128) int32

func Int32FromComplex64 

func Int32FromComplex64(n complex64) 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 Int64FromComplex128 

func Int64FromComplex128(n complex128) int64

func Int64FromComplex64 

func Int64FromComplex64(n complex64) 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 Int8FromComplex128 

func Int8FromComplex128(n complex128) int8

func Int8FromComplex64 

func Int8FromComplex64(n complex64) 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 MemAuditReport 

func MemAuditReport() error

MemAuditReport locks the memory allocator, reports memory leaks, if any. Finally it disables memory auditing and unlocks the memory allocator.

This memory auditing functionality has to be enabled using the libc.memgrind build tag.

It is intended only for debug/test builds. It slows down memory allocation routines and it has additional memory costs.

func MemAuditStart 

func MemAuditStart()

MemAuditStart locks the memory allocator, initializes and enables memory auditing. Finaly it unlocks the memory allocator.

Some memory handling errors, like double free or freeing of unallocated memory, will panic when memory auditing is enabled.

This memory auditing functionality has to be enabled using the libc.memgrind build tag.

It is intended only for debug/test builds. It slows down memory allocation routines and it has additional memory costs.

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 NewVaList 

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

NewVaList is like VaList but automatically allocates the correct amount of memory for all of the items in args.

The va_list return value is used to pass the constructed var args to var args accepting functions. The caller of NewVaList is responsible for freeing the va_list.

func NewVaListN 

func NewVaListN(n int) (va_list uintptr)

NewVaListN returns a newly allocated va_list for n items. The caller of NewVaListN is responsible for freeing the va_list.

func PostDecAtomicInt32 

func PostDecAtomicInt32(p *int32, d int32) int32

func PostDecAtomicInt64 

func PostDecAtomicInt64(p *int64, d int64) int64

func PostDecAtomicUint32 

func PostDecAtomicUint32(p *uint32, d uint32) uint32

func PostDecAtomicUint64 

func PostDecAtomicUint64(p *uint64, d uint64) uint64

func PostDecAtomicUintptr 

func PostDecAtomicUintptr(p *uintptr, d 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 PostDecComplex128 

func PostDecComplex128(p *complex128, d complex128) complex128

func PostDecComplex64 

func PostDecComplex64(p *complex64, d complex64) complex64

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 PostIncAtomicInt32 

func PostIncAtomicInt32(p *int32, d int32) int32

func PostIncAtomicInt64 

func PostIncAtomicInt64(p *int64, d int64) int64

func PostIncAtomicUint32 

func PostIncAtomicUint32(p *uint32, d uint32) uint32

func PostIncAtomicUint64 

func PostIncAtomicUint64(p *uint64, d uint64) uint64

func PostIncAtomicUintptr 

func PostIncAtomicUintptr(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 PostIncComplex128 

func PostIncComplex128(p *complex128, d complex128) complex128

func PostIncComplex64 

func PostIncComplex64(p *complex64, d complex64) complex64

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 PreDecAtomicInt32 

func PreDecAtomicInt32(p *int32, d int32) int32

func PreDecAtomicInt64 

func PreDecAtomicInt64(p *int64, d int64) int64

func PreDecAtomicUint32 

func PreDecAtomicUint32(p *uint32, d uint32) uint32

func PreDecAtomicUint64 

func PreDecAtomicUint64(p *uint64, d uint64) uint64

func PreDecAtomicUintptr 

func PreDecAtomicUintptr(p *uintptr, d uintptr) uintptr

func PreDecComplex128 

func PreDecComplex128(p *complex128, d complex128) complex128

func PreDecComplex64 

func PreDecComplex64(p *complex64, d complex64) complex64

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 PreIncAtomicInt32 

func PreIncAtomicInt32(p *int32, d int32) int32

func PreIncAtomicInt64 

func PreIncAtomicInt64(p *int64, d int64) int64

func PreIncAtomicUint32 

func PreIncAtomicUint32(p *uint32, d uint32) uint32

func PreIncAtomicUint64 

func PreIncAtomicUint64(p *uint64, d uint64) uint64

func PreIncAtomicUintptr 

func PreIncAtomicUintptr(p *uintptr, d uintptr) uintptr

func PreIncComplex128 

func PreIncComplex128(p *complex128, d complex128) complex128

func PreIncComplex64 

func PreIncComplex64(p *complex64, d complex64) complex64

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 SetEnviron 

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

func Start 

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

func Uint16 

func Uint16(n uint16) uint16

func Uint16FromComplex128 

func Uint16FromComplex128(n complex128) uint16

func Uint16FromComplex64 

func Uint16FromComplex64(n complex64) 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 Uint32FromComplex128 

func Uint32FromComplex128(n complex128) uint32

func Uint32FromComplex64 

func Uint32FromComplex64(n complex64) 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 Uint64FromComplex128 

func Uint64FromComplex128(n complex128) uint64

func Uint64FromComplex64 

func Uint64FromComplex64(n complex64) 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 Uint8FromComplex128 

func Uint8FromComplex128(n complex128) uint8

func Uint8FromComplex64 

func Uint8FromComplex64(n complex64) 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 UintptrFromComplex128 

func UintptrFromComplex128(n complex128) uintptr

func UintptrFromComplex64 

func UintptrFromComplex64(n complex64) 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 UsableSize 

func UsableSize(p uintptr) types.Size_t

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 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.

This function supports code generated by ccgo/v3. For manually constructed var args it's recommended to use the NewVaList function instead.

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

func VaUint32 

func VaUint32(app *uintptr) uint32

func VaUint64 

func VaUint64(app *uintptr) uint64

func VaUintptr 

func VaUintptr(app *uintptr) uintptr

func Watch 

func Watch()

func WatchDelete 

func WatchDelete(p uintptr)

func WatchFloat32 

func WatchFloat32(p uintptr, msg string)

func WatchFloat64 

func WatchFloat64(p uintptr, msg string)

func WatchInt16 

func WatchInt16(p uintptr, msg string)

func WatchInt32 

func WatchInt32(p uintptr, msg string)

func WatchInt64 

func WatchInt64(p uintptr, msg string)

func WatchInt8 

func WatchInt8(p uintptr, msg string)

func WatchPtr 

func WatchPtr(p uintptr, msg string)

func WatchUint16 

func WatchUint16(p uintptr, msg string)

func WatchUint32 

func WatchUint32(p uintptr, msg string)

func WatchUint64 

func WatchUint64(p uintptr, msg string)

func WatchUint8 

func WatchUint8(p uintptr, msg string)

func X_IO_putc 

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

int _IO_putc(int __c, _IO_FILE *__fp);

func X___errno_location 

func X___errno_location(t *TLS) 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___memcpy_chk 

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

void * __builtin___memcpy_chk (void *dest, const void *src, size_t n, size_t os);

func X__builtin___memmove_chk 

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

void * __builtin___memmove_chk (void *dest, const void *src, size_t n, size_t os);

func X__builtin___memset_chk 

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

void * __builtin___memset_chk (void *s, int c, size_t n, size_t os);

func X__builtin___snprintf_chk 

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

int __builtin___snprintf_chk(char * str, size_t maxlen, int flag, size_t os, const char * format, ...);

func X__builtin___sprintf_chk 

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

int __builtin___sprintf_chk (char *s, int flag, size_t os, const char *fmt, ...);

func X__builtin___strcat_chk 

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

char * __builtin___strcat_chk (char *dest, const char *src, size_t os);

func X__builtin___strcpy_chk 

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

char * __builtin___strcpy_chk (char *dest, const char *src, size_t os);

func X__builtin___strncpy_chk 

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

char * __builtin___strncpy_chk (char *dest, const char *src, size_t n, size_t os);

func X__builtin___vsnprintf_chk 

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

int __builtin___vsnprintf_chk (char *s, size_t maxlen, int flag, size_t os, const char *fmt, va_list ap);

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_add_overflowInt64 

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

bool __builtin_add_overflow (type1 a, type2 b, type3 *res)

func X__builtin_add_overflowUint32 

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

bool __builtin_add_overflow (type1 a, type2 b, type3 *res)

func X__builtin_add_overflowUint64 

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

bool __builtin_add_overflow (type1 a, type2 b, type3 *res)

func X__builtin_bswap16 

func X__builtin_bswap16(t *TLS, x uint16) uint16

uint16_t __builtin_bswap16 (uint32_t x)

func X__builtin_bswap32 

func X__builtin_bswap32(t *TLS, x uint32) uint32

uint32_t __builtin_bswap32 (uint32_t x)

func X__builtin_bswap64 

func X__builtin_bswap64(t *TLS, x uint64) uint64

uint64_t __builtin_bswap64 (uint64_t x)

func X__builtin_bzero 

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

func X__builtin_clz 

func X__builtin_clz(t *TLS, n uint32) int32

func X__builtin_clzl 

func X__builtin_clzl(t *TLS, n ulong) int32

func X__builtin_clzll 

func X__builtin_clzll(t *TLS, n uint64) int32

func X__builtin_constant_p_impl 

func X__builtin_constant_p_impl()

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_copysignl 

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

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_fabsf 

func X__builtin_fabsf(t *TLS, x float32) float32

func X__builtin_fabsl 

func X__builtin_fabsl(t *TLS, x float64) float64

func X__builtin_free 

func X__builtin_free(t *TLS, ptr uintptr)

func X__builtin_getentropy 

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

func X__builtin_huge_val 

func X__builtin_huge_val(t *TLS) float64

func X__builtin_huge_valf 

func X__builtin_huge_valf(t *TLS) float32

func X__builtin_inf 

func X__builtin_inf(t *TLS) float64

func X__builtin_inff 

func X__builtin_inff(t *TLS) float32

func X__builtin_infl 

func X__builtin_infl(t *TLS) float64

func X__builtin_isnan 

func X__builtin_isnan(t *TLS, x float64) int32

func X__builtin_isunordered 

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

func X__builtin_llabs 

func X__builtin_llabs(tls *TLS, a int64) int64

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_mmap 

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

func X__builtin_mul_overflowInt64 

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

bool __builtin_mul_overflow (type1 a, type2 b, type3 *res)

func X__builtin_mul_overflowUint128 

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

bool __builtin_mul_overflow (type1 a, type2 b, type3 *res)

func X__builtin_mul_overflowUint64 

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

bool __builtin_mul_overflow (type1 a, type2 b, type3 *res)

func X__builtin_nan 

func X__builtin_nan(t *TLS, s uintptr) float64

func X__builtin_nanf 

func X__builtin_nanf(t *TLS, s uintptr) float32

func X__builtin_nanl 

func X__builtin_nanl(t *TLS, s uintptr) float64

func X__builtin_object_size 

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

size_t __builtin_object_size (const void * ptr, int type)

func X__builtin_popcount 

func X__builtin_popcount(t *TLS, x uint32) int32

int __builtin_popcount (unsigned int x)

func X__builtin_popcountl 

func X__builtin_popcountl(t *TLS, x ulong) int32

int __builtin_popcountl (unsigned long x)

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_sub_overflowInt64 

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

bool __builtin_sub_overflow (type1 a, type2 b, type3 *res)

func X__builtin_trap 

func X__builtin_trap(t *TLS)

func X__builtin_unreachable 

func X__builtin_unreachable(t *TLS)

func X__ccgo_dmesg 

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

func X__ccgo_getMutexType 

func X__ccgo_getMutexType(tls *TLS, m uintptr) int32

func X__ccgo_in6addr_anyp 

func X__ccgo_in6addr_anyp(t *TLS) uintptr

func X__ccgo_pthreadAttrGetDetachState 

func X__ccgo_pthreadAttrGetDetachState(tls *TLS, a uintptr) int32

func X__ccgo_pthreadMutexattrGettype 

func X__ccgo_pthreadMutexattrGettype(tls *TLS, a uintptr) int32

func X__ccgo_sqlite3_log 

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

void sqlite3_log(int iErrCode, const char *zFormat, ...);

func X__cmsg_nxthdr 

func X__cmsg_nxthdr(t *TLS, msgh, cmsg uintptr) uintptr

struct cmsghdr *CMSG_NXTHDR(struct msghdr *msgh, struct cmsghdr *cmsg);

func X__ctype_b_loc 

func X__ctype_b_loc(tls *TLS) uintptr

func X__ctype_get_mb_cur_max 

func X__ctype_get_mb_cur_max(t *TLS) types.Size_t

size_t __ctype_get_mb_cur_max(void);

func X__errno_location 

func X__errno_location(t *TLS) uintptr

int * __errno_location(void);

func X__floatscan 

func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) float64

func X__fpclassify 

func X__fpclassify(tls *TLS, x float64) int32

func X__fpclassifyf 

func X__fpclassifyf(tls *TLS, x float32) int32

func X__fpclassifyl 

func X__fpclassifyl(tls *TLS, x float64) int32

func X__h_errno_location 

func X__h_errno_location(tls *TLS) uintptr

func X__inet_aton 

func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) int32

func X__intscan 

func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) uint64

func X__isalnum_l 

func X__isalnum_l(tls *TLS, c int32, l locale_t) int32

func X__isalpha_l 

func X__isalpha_l(tls *TLS, c int32, l locale_t) int32

func X__isdigit_l 

func X__isdigit_l(tls *TLS, c int32, l locale_t) int32

func X__islower_l 

func X__islower_l(tls *TLS, c int32, l locale_t) int32

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__isprint_l 

func X__isprint_l(tls *TLS, c int32, l locale_t) int32

func X__isupper_l 

func X__isupper_l(tls *TLS, c int32, l locale_t) int32

func X__isxdigit_l 

func X__isxdigit_l(tls *TLS, c int32, l locale_t) int32

func X__lockfile 

func X__lockfile(tls *TLS, f uintptr) int32

func X__lookup_ipliteral 

func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) int32

func X__lookup_name 

func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family int32, flags int32) int32

func X__lookup_serv 

func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype int32, flags int32) int32

func X__shgetc 

func X__shgetc(tls *TLS, f uintptr) int32

func X__shlim 

func X__shlim(tls *TLS, f uintptr, lim off_t)

func X__strncasecmp_l 

func X__strncasecmp_l(tls *TLS, l uintptr, r uintptr, n size_t, loc locale_t) int32

func X__sync_add_and_fetch_uint32 

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

unsigned __sync_add_and_fetch_uint32(*unsigned, unsigned)

func X__sync_sub_and_fetch_uint32 

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

unsigned __sync_sub_and_fetch_uint32(*unsigned, unsigned)

func X__sync_synchronize 

func X__sync_synchronize(t *TLS)

__sync_synchronize();

func X__syscall1 

func X__syscall1(t *TLS, trap, p1 long) long

func X__syscall3 

func X__syscall3(t *TLS, trap, p1, p2, p3 long) long

func X__syscall4 

func X__syscall4(t *TLS, trap, p1, p2, p3, p4 long) long

func X__toread 

func X__toread(tls *TLS, f uintptr) int32

func X__toread_needs_stdio_exit 

func X__toread_needs_stdio_exit(tls *TLS)

func X__uflow 

func X__uflow(tls *TLS, f uintptr) int32

func X__unlockfile 

func X__unlockfile(tls *TLS, f uintptr)

func X_exit 

func X_exit(_ *TLS, status int32)

void _exit(int status);

func X_longjmp 

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

void _longjmp(jmp_buf env, int val);

func X_obstack_begin 

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

int _obstack_begin (struct obstack *h, _OBSTACK_SIZE_T size, _OBSTACK_SIZE_T alignment, void *(*chunkfun) (size_t), void (*freefun) (void *))

func X_obstack_newchunk 

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

extern void _obstack_newchunk(struct obstack *, int);

func X_setjmp 

func X_setjmp(t *TLS, env uintptr) int32

int _setjmp(jmp_buf env);

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 Xacosh 

func Xacosh(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 Xasinh 

func Xasinh(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 Xatanh 

func Xatanh(t *TLS, x float64) float64

func Xatexit 

func Xatexit(t *TLS, function uintptr) int32

int atexit(void (*function)(void));

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 Xbsearch 

func Xbsearch(tls *TLS, key uintptr, base uintptr, nel size_t, width size_t, cmp uintptr) uintptr

func Xbzero 

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

void bzero(void *s, size_t n);

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 Xceilf 

func Xceilf(t *TLS, x float32) float32

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 Xclock_gettime 

func Xclock_gettime(t *TLS, clk_id int32, tp uintptr) int32

int clock_gettime(clockid_t clk_id, struct timespec *tp);

func Xclose 

func Xclose(t *TLS, fd int32) int32

int close(int fd);

func Xclosedir 

func Xclosedir(tls *TLS, dir uintptr) int32

func Xconfstr 

func Xconfstr(t *TLS, name int32, buf uintptr, len types.Size_t) types.Size_t

size_t confstr(int name, char *buf, size_t len);

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 Xcopysignl 

func Xcopysignl(tls *TLS, x float64, y float64) float64

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 Xctime 

func Xctime(t *TLS, timep uintptr) uintptr

char *ctime(const time_t *timep);

func Xctime_r 

func Xctime_r(t *TLS, timep, buf uintptr) uintptr

char *ctime_r(const time_t *timep, char *buf);

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 Xdup3 

func Xdup3(t *TLS, oldfd int32, newfd int32, flags int32) int32

int dup3(int oldfd, int newfd, int flags);

func Xendpwent 

func Xendpwent(t *TLS)

void endpwent(void);

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 Xfabsl 

func Xfabsl(tls *TLS, x float64) float64

func Xfaccessat 

func Xfaccessat(t *TLS, dirfd int32, pathname uintptr, mode, flags int32) int32

int faccessat(int dirfd, const char *pathname, int mode, int flags);

func Xfchmod 

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

int fchmod(int fd, mode_t mode);

func Xfchmodat 

func Xfchmodat(t *TLS, dirfd int32, pathname uintptr, mode types.Mode_t, flags int32) int32

int fchmodat(int dirfd, const char *pathname, mode_t mode, int flags);

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 Xfchownat 

func Xfchownat(t *TLS, dirfd int32, pathname uintptr, uid types.Uid_t, gid types.Gid_t, flags int32) int32

int fchownat(int dirfd, const char *pathname, uid_t owner, gid_t group, int flags);

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 Xfmodl 

func Xfmodl(tls *TLS, x float64, 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(tls *TLS, p uintptr)

func Xfrexp 

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

func Xfscanf 

func Xfscanf(t *TLS, stream, format, va uintptr) int32

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

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 Xfstatfs 

func Xfstatfs(t *TLS, fd int32, buf uintptr) int32

int fstatfs(int fd, struct statfs *buf);

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.Off_t) int32

int ftruncate(int fd, off_t length);

func Xfts64_close 

func Xfts64_close(t *TLS, ftsp uintptr) int32

int fts_close(FTS *ftsp);

func Xfts64_open 

func Xfts64_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 Xfts64_read 

func Xfts64_read(t *TLS, ftsp uintptr) uintptr

FTSENT *fts_read(FTS *ftsp);

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(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintptr) int32

func Xgetc 

func Xgetc(t *TLS, stream uintptr) int32

int getc(FILE *stream);

func Xgetcwd 

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

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

func Xgetegid 

func Xgetegid(t *TLS) types.Gid_t

gid_t getegid(void);

func Xgetentropy 

func Xgetentropy(t *TLS, buffer uintptr, length size_t) int32

int getentropy(void *buffer, size_t length);

The getentropy() function writes length bytes of high-quality random data to the buffer starting at the location pointed to by buffer. The maximum permitted value for the length argument is 256.

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 Xgetgid 

func Xgetgid(t *TLS) types.Gid_t

gid_t getgid(void);

func Xgetgrgid 

func Xgetgrgid(t *TLS, gid uint32) uintptr

struct group *getgrgid(gid_t gid);

func Xgetgrgid_r 

func Xgetgrgid_r(t *TLS, gid uint32, pGrp, buf uintptr, buflen types.Size_t, result uintptr) int32

int getgrgid_r(gid_t gid, struct group *grp, char *buf, size_t buflen, struct group **result);

func Xgetgrnam 

func Xgetgrnam(t *TLS, name uintptr) uintptr

struct group *getgrnam(const char *name);

func Xgetgrnam_r 

func Xgetgrnam_r(t *TLS, name, pGrp, buf uintptr, buflen types.Size_t, result uintptr) int32

int getgrnam_r(const char *name, struct group *grp, char *buf, size_t buflen, struct group **result);

func Xgethostbyaddr 

func Xgethostbyaddr(tls *TLS, a uintptr, l socklen_t, af int32) uintptr

func Xgethostbyaddr_r 

func Xgethostbyaddr_r(tls *TLS, a uintptr, l socklen_t, af int32, h uintptr, buf uintptr, buflen size_t, res uintptr, err uintptr) int32

func Xgethostbyname 

func Xgethostbyname(tls *TLS, name uintptr) uintptr

func Xgethostbyname2 

func Xgethostbyname2(tls *TLS, name uintptr, af int32) uintptr

func Xgethostbyname2_r 

func Xgethostbyname2_r(tls *TLS, name uintptr, af int32, h uintptr, buf uintptr, buflen size_t, res uintptr, err uintptr) int32

func Xgethostbyname_r 

func Xgethostbyname_r(tls *TLS, name uintptr, h uintptr, buf uintptr, buflen size_t, res uintptr, err uintptr) int32

func Xgethostname 

func Xgethostname(t *TLS, name uintptr, slen types.Size_t) int32

int gethostname(char *name, size_t len);

func Xgetnameinfo 

func Xgetnameinfo(tls *TLS, sa1 uintptr, sl socklen_t, node uintptr, nodelen socklen_t, serv uintptr, servlen socklen_t, flags int32) int32

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 Xgetpwnam_r 

func Xgetpwnam_r(t *TLS, name, cpwd, buf uintptr, buflen types.Size_t, result uintptr) int32

int getpwnam_r(char *name, struct passwd *pwd, char *buf, size_t buflen, struct passwd **result);

func Xgetpwuid 

func Xgetpwuid(t *TLS, uid uint32) uintptr

struct passwd *getpwuid(uid_t uid);

func Xgetpwuid_r 

func Xgetpwuid_r(t *TLS, uid types.Uid_t, cpwd, buf uintptr, buflen types.Size_t, result uintptr) int32

int getpwuid_r(uid_t uid, struct passwd *pwd, char *buf, size_t buflen, struct passwd **result);

func Xgetrandom 

func Xgetrandom(t *TLS, buf uintptr, buflen size_t, flags uint32) ssize_t

ssize_t getrandom(void *buf, size_t buflen, unsigned int flags);

func Xgetresgid 

func Xgetresgid(t *TLS, rgid, egid, sgid uintptr) int32

int getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid);

func Xgetresuid 

func Xgetresuid(t *TLS, ruid, euid, suid uintptr) int32

int getresuid(uid_t *ruid, uid_t *euid, uid_t *suid);

func Xgetrlimit 

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

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

func Xgetrlimit64 

func Xgetrlimit64(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 Xinet_ntop 

func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l socklen_t) uintptr

func Xinet_pton 

func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) int32

func Xinitstate 

func Xinitstate(t *TLS, seed uint32, statebuf uintptr, statelen types.Size_t) uintptr

char *initstate(unsigned seed, char *state, size_t size);

func Xinitstate_r 

func Xinitstate_r(t *TLS, seed uint32, statebuf uintptr, statelen types.Size_t, buf uintptr) int32

The initstate_r() function is like initstate(3) except that it initializes the state in the object pointed to by buf, rather than initializing the global state variable. Before calling this function, the buf.state field must be initialized to NULL. The initstate_r() function records a pointer to the statebuf argument inside the structure pointed to by buf. Thus, state‐ buf should not be deallocated so long as buf is still in use. (So, statebuf should typically be allocated as a static variable, or allocated on the heap using malloc(3) or similar.)

char *initstate_r(unsigned int seed, char *statebuf, size_t statelen, struct random_data *buf);

func Xioctl 

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

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

func Xisalnum 

func Xisalnum(tls *TLS, c int32) int32

func Xisalpha 

func Xisalpha(tls *TLS, c int32) int32

func Xisascii 

func Xisascii(t *TLS, c int32) int32

int isascii(int c);

func Xisatty 

func Xisatty(t *TLS, fd int32) int32

int isatty(int fd);

func Xisdigit 

func Xisdigit(tls *TLS, c int32) int32

func Xislower 

func Xislower(tls *TLS, c int32) int32

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 Xisprint 

func Xisprint(tls *TLS, c int32) int32

func Xisupper 

func Xisupper(tls *TLS, c int32) int32

func Xiswalnum 

func Xiswalnum(t *TLS, wc wctype.Wint_t) int32

int iswalnum(wint_t wc);

func Xiswspace 

func Xiswspace(t *TLS, wc wctype.Wint_t) int32

int iswspace(wint_t wc);

func Xisxdigit 

func Xisxdigit(tls *TLS, c int32) int32

func Xkill 

func Xkill(t *TLS, pid types.Pid_t, sig int32) int32

int kill(pid_t pid, int sig);

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 Xlinkat 

func Xlinkat(t *TLS, olddirfd int32, oldpath uintptr, newdirfd int32, newpath uintptr, flags int32) int32

int linkat(int olddirfd, const char *oldpath, int newdirfd, const char *newpath, int flags);

func Xlisten 

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

int listen(int sockfd, int backlog);

func Xllabs 

func Xllabs(tls *TLS, a int64) int64

func Xlocaleconv 

func Xlocaleconv(tls *TLS) uintptr

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 Xlog2 

func Xlog2(t *TLS, x float64) float64

func Xlongjmp 

func Xlongjmp(t *TLS, env uintptr, val int32)

void longjmp(jmp_buf env, int val);

func Xlrand48 

func Xlrand48(t *TLS) long

long int lrand48(void);

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.Off_t, whence int32) types.Off_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 Xmblen 

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

int mblen(const char *s, size_t n);

func Xmbrtowc 

func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n size_t, st uintptr) size_t

func Xmbsinit 

func Xmbsinit(tls *TLS, st uintptr) int32

func Xmbstowcs 

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

size_t mbstowcs(wchar_t *dest, const char *src, size_t n);

func Xmbtowc 

func Xmbtowc(t *TLS, pwc, s uintptr, n types.Size_t) int32

int mbtowc(wchar_t *pwc, const char *s, size_t n);

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 Xmkdirat 

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

int mkdirat(int dirfd, const char *pathname, 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 Xmknodat 

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

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

func Xmkostemp 

func Xmkostemp(t *TLS, template uintptr, flags int32) int32

int mkostemp(char *template, int flags);

func Xmkstemp 

func Xmkstemp(t *TLS, template uintptr) int32

int mkstemp(char *template);

func Xmkstemp64 

func Xmkstemp64(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 Xmkstemps64 

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

int mkstemps(char *template, int suffixlen);

func Xmktime 

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

time_t mktime(struct tm *tm);

func Xmmap 

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

func Xmmap64 

func Xmmap64(t *TLS, addr uintptr, length types.Size_t, prot, flags, fd int32, offset types.Off_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 Xmremap 

func Xmremap(t *TLS, old_address uintptr, old_size, new_size types.Size_t, flags int32, args uintptr) uintptr

void *mremap(void *old_address, size_t old_size, size_t new_size, int flags, ... /* void *new_address */);

func Xmunmap 

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

int munmap(void *addr, size_t length);

func Xnanf 

func Xnanf(tls *TLS, s uintptr) float32

func Xnanosleep 

func Xnanosleep(t *TLS, req, rem uintptr) int32

int nanosleep(const struct timespec *req, struct timespec *rem);

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 Xobstack_free 

func Xobstack_free(t *TLS, obstack, obj uintptr)

void obstack_free (struct obstack *h, void *obj)

func Xobstack_vprintf 

func Xobstack_vprintf(t *TLS, obstack, template, va uintptr) int32

int obstack_vprintf (struct obstack *obstack, const char *template, va_list ap)

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 Xopenat 

func Xopenat(t *TLS, dirfd int32, pathname uintptr, flags int32, mode types.Mode_t) int32

int openat(int dirfd, const char *pathname, int flags, mode_t mode);

func Xopendir 

func Xopendir(tls *TLS, name uintptr) uintptr

func Xopenpty 

func Xopenpty(t *TLS, amaster, aslave, name, termp, winp uintptr) int32

int openpty(int *amaster, int *aslave, char *name, 

const struct termios *termp,
const struct winsize *winp);

func Xpathconf 

func Xpathconf(t *TLS, path uintptr, name int32) long

long pathconf(const char *path, int name);

func Xpause 

func Xpause(t *TLS) int32

int pause(void);

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 Xpipe2 

func Xpipe2(t *TLS, pipefd uintptr, flags int32) int32

int pipe2(int pipefd[2], int flags);

func Xpoll 

func Xpoll(t *TLS, fds uintptr, nfds poll.Nfds_t, timeout int32) int32

int poll(struct pollfd *fds, nfds_t nfds, int timeout);

func Xpopen 

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

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

func Xposix_fadvise 

func Xposix_fadvise(t *TLS, fd int32, offset, len types.Off_t, advice int32) int32

int posix_fadvise(int fd, off_t offset, off_t len, int advice);

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 Xpselect 

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

int pselect(int nfds, fd_set *readfds, fd_set *writefds, 

fd_set *exceptfds, const struct timespec *timeout,
const sigset_t *sigmask);

func Xpthread_attr_destroy 

func Xpthread_attr_destroy(t *TLS, pAttr uintptr) int32

int pthread_attr_destroy(pthread_attr_t *attr);

func Xpthread_attr_getdetachstate 

func Xpthread_attr_getdetachstate(tls *TLS, a uintptr, state uintptr) int32

func Xpthread_attr_init 

func Xpthread_attr_init(t *TLS, pAttr uintptr) int32

int pthread_attr_init(pthread_attr_t *attr);

func Xpthread_attr_setdetachstate 

func Xpthread_attr_setdetachstate(tls *TLS, a uintptr, state int32) int32

func Xpthread_attr_setscope 

func Xpthread_attr_setscope(t *TLS, pAttr uintptr, contentionScope int32) int32

int pthread_attr_setscope(pthread_attr_t *attr, int contentionscope);

func Xpthread_attr_setstacksize 

func Xpthread_attr_setstacksize(t *TLS, attr uintptr, stackSize types.Size_t) int32

int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize);

func Xpthread_cond_broadcast 

func Xpthread_cond_broadcast(t *TLS, pCond uintptr) int32

int pthread_cond_broadcast(pthread_cond_t *cond);

func Xpthread_cond_destroy 

func Xpthread_cond_destroy(t *TLS, pCond uintptr) int32

int pthread_cond_destroy(pthread_cond_t *cond);

func Xpthread_cond_init 

func Xpthread_cond_init(t *TLS, pCond, pAttr uintptr) int32

The pthread_cond_init() function shall initialize the condition variable referenced by cond with attributes referenced by attr. If attr is NULL, the default condition variable attributes shall be used; the effect is the same as passing the address of a default condition variable attributes object. Upon successful initialization, the state of the condition variable shall become initialized.

If successful, the pthread_cond_destroy() and pthread_cond_init() functions shall return zero; otherwise, an error number shall be returned to indicate the error.

int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);

func Xpthread_cond_signal 

func Xpthread_cond_signal(t *TLS, pCond uintptr) int32

int pthread_cond_signal(pthread_cond_t *cond);

func Xpthread_cond_timedwait 

func Xpthread_cond_timedwait(t *TLS, pCond, pMutex, pAbsTime uintptr) int32

int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict abstime);

func Xpthread_cond_wait 

func Xpthread_cond_wait(t *TLS, pCond, pMutex uintptr) int32

int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);

func Xpthread_create 

func Xpthread_create(t *TLS, pThread, pAttr, startRoutine, arg uintptr) int32

int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);

func Xpthread_detach 

func Xpthread_detach(t *TLS, thread pthread.Pthread_t) int32

int pthread_detach(pthread_t thread);

func Xpthread_equal 

func Xpthread_equal(t *TLS, t1, t2 pthread.Pthread_t) int32

int pthread_equal(pthread_t t1, pthread_t t2);

func Xpthread_exit 

func Xpthread_exit(t *TLS, value uintptr)

void pthread_exit(void *value_ptr);

func Xpthread_getspecific 

func Xpthread_getspecific(t *TLS, key pthread.Pthread_key_t) uintptr

void *pthread_getspecific(pthread_key_t key);

func Xpthread_join 

func Xpthread_join(t *TLS, thread pthread.Pthread_t, pValue uintptr) int32

int pthread_join(pthread_t thread, void **value_ptr);

func Xpthread_key_create 

func Xpthread_key_create(t *TLS, pKey, destructor uintptr) int32

int pthread_key_create(pthread_key_t *key, void (*destructor)(void*));

func Xpthread_key_delete 

func Xpthread_key_delete(t *TLS, key pthread.Pthread_key_t) int32

int pthread_key_delete(pthread_key_t key);

func Xpthread_mutex_destroy 

func Xpthread_mutex_destroy(t *TLS, pMutex uintptr) int32

int pthread_mutex_destroy(pthread_mutex_t *mutex);

func Xpthread_mutex_init 

func Xpthread_mutex_init(t *TLS, pMutex, pAttr uintptr) int32

The pthread_mutex_init() function shall initialize the mutex referenced by mutex with attributes specified by attr. If attr is NULL, the default mutex attributes are used; the effect shall be the same as passing the address of a default mutex attributes object. Upon successful initialization, the state of the mutex becomes initialized and unlocked.

If successful, the pthread_mutex_destroy() and pthread_mutex_init() functions shall return zero; otherwise, an error number shall be returned to indicate the error.

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);

func Xpthread_mutex_lock 

func Xpthread_mutex_lock(t *TLS, pMutex uintptr) int32

int pthread_mutex_lock(pthread_mutex_t *mutex);

func Xpthread_mutex_trylock 

func Xpthread_mutex_trylock(t *TLS, pMutex uintptr) int32

int pthread_mutex_trylock(pthread_mutex_t *mutex);

func Xpthread_mutex_unlock 

func Xpthread_mutex_unlock(t *TLS, pMutex uintptr) int32

int pthread_mutex_unlock(pthread_mutex_t *mutex);

func Xpthread_mutexattr_destroy 

func Xpthread_mutexattr_destroy(tls *TLS, a uintptr) int32

func Xpthread_mutexattr_init 

func Xpthread_mutexattr_init(tls *TLS, a uintptr) int32

func Xpthread_mutexattr_settype 

func Xpthread_mutexattr_settype(tls *TLS, a uintptr, type1 int32) int32

func Xpthread_self 

func Xpthread_self(t *TLS) pthread.Pthread_t

pthread_t pthread_self(void);

func Xpthread_setspecific 

func Xpthread_setspecific(t *TLS, key pthread.Pthread_key_t, value uintptr) int32

int pthread_setspecific(pthread_key_t key, const void *value);

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 Xputs 

func Xputs(t *TLS, s uintptr) int32

int puts(const char *s);

func Xpwrite 

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

ssize_t pwrite(int fd, const void *buf, size_t count, off_t offset);

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 Xrand_r 

func Xrand_r(tls *TLS, seed uintptr) int32

func Xrandom 

func Xrandom(t *TLS) long

long int random(void);

func Xrandom_r 

func Xrandom_r(t *TLS, buf, result uintptr) int32

int random_r(struct random_data *buf, int32_t *result);

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(tls *TLS, dir uintptr) uintptr

func Xreaddir64 

func Xreaddir64(t *TLS, dir uintptr) uintptr
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 Xreadlinkat 

func Xreadlinkat(t *TLS, dirfd int32, pathname, buf uintptr, bufsiz types.Size_t) types.Ssize_t

ssize_t readlinkat(int dirfd, const char *pathname, char *buf, size_t bufsiz);

func Xreadv 

func Xreadv(t *TLS, fd int32, iov uintptr, iovcnt int32) types.Ssize_t

ssize_t readv(int fd, const struct iovec *iov, int iovcnt);

func Xrealloc 

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

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

func Xreallocarray 

func Xreallocarray(t *TLS, ptr uintptr, nmemb, size size_t) uintptr

void * reallocarray(void *ptr, size_t nmemb, 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 Xrecvfrom 

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

ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen);

func Xrecvmsg 

func Xrecvmsg(t *TLS, sockfd int32, msg uintptr, flags int32) types.Ssize_t

ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);

func Xremove 

func Xremove(t *TLS, pathname uintptr) int32

int remove(const char *pathname);

func Xrename 

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

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

func Xrenameat2 

func Xrenameat2(t *TLS, olddirfd int32, oldpath uintptr, newdirfd int32, newpath uintptr, flags int32) int32

int renameat2(int olddirfd, const char *oldpath, int newdirfd, const char *newpath, unsigned int flags);

func Xrewind 

func Xrewind(t *TLS, stream uintptr)

void rewind(FILE *stream);

func Xrindex 

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

char *rindex(const char *s, int c);

func Xrint 

func Xrint(tls *TLS, x float64) float64

func Xrmdir 

func Xrmdir(t *TLS, pathname uintptr) int32

int rmdir(const char *pathname);

func Xround 

func Xround(t *TLS, x float64) float64

func Xscalbn 

func Xscalbn(tls *TLS, x float64, n int32) float64

func Xscalbnl 

func Xscalbnl(tls *TLS, x float64, n int32) float64

func Xsched_yield 

func Xsched_yield(t *TLS)

int sched_yield(void);

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 Xsendmsg 

func Xsendmsg(t *TLS, sockfd int32, msg uintptr, flags int32) types.Ssize_t

ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);

func Xsendto 

func Xsendto(t *TLS, sockfd int32, buf uintptr, len types.Size_t, flags int32, src_addr uintptr, addrlen socklen_t) types.Ssize_t

ssize_t sendto(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen);

func Xsetbuf 

func Xsetbuf(t *TLS, stream, buf uintptr)

void setbuf(FILE *stream, char *buf);

func Xsetenv 

func Xsetenv(t *TLS, name, value uintptr, overwrite int32) int32

int setenv(const char *name, const char *value, int overwrite);

func Xsetjmp 

func Xsetjmp(t *TLS, env uintptr) int32

int setjmp(jmp_buf env);

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 Xsetrlimit64 

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

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

func Xsetsid 

func Xsetsid(t *TLS) types.Pid_t

pid_t setsid(void);

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 Xsetstate 

func Xsetstate(t *TLS, state uintptr) uintptr

char *setstate(const char *state);

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 Xshmat 

func Xshmat(t *TLS, shmid int32, shmaddr uintptr, shmflg int32) uintptr

void *shmat(int shmid, const void *shmaddr, int shmflg);

func Xshmctl 

func Xshmctl(t *TLS, shmid, cmd int32, buf uintptr) int32

int shmctl(int shmid, int cmd, struct shmid_ds *buf);

func Xshmdt 

func Xshmdt(t *TLS, shmaddr uintptr) int32

int shmdt(const void *shmaddr);

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 Xsrand48 

func Xsrand48(t *TLS, seedval long)

void srand48(long int seedval);

func Xsscanf 

func Xsscanf(tls *TLS, s uintptr, fmt uintptr, va uintptr) int32

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(tls *TLS, s uintptr) uintptr

func Xstrerror 

func Xstrerror(t *TLS, errnum int32) uintptr

char *strerror(int errnum);

func Xstrerror_r 

func Xstrerror_r(t *TLS, errnum int32, buf uintptr, buflen size_t) int32

int strerror_r(int errnum, char *buf, size_t buflen);

func Xstrlcat 

func Xstrlcat(tls *TLS, d uintptr, s uintptr, n size_t) size_t

func Xstrlcpy 

func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n size_t) size_t

func Xstrlen 

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

size_t strlen(const char *s)

func Xstrncasecmp 

func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n size_t) int32

func Xstrncat 

func Xstrncat(tls *TLS, d uintptr, s uintptr, n size_t) uintptr

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 Xstrnlen 

func Xstrnlen(tls *TLS, s uintptr, n size_t) size_t

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 Xstrspn 

func Xstrspn(tls *TLS, s uintptr, c uintptr) size_t

func Xstrstr 

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

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

func Xstrtod 

func Xstrtod(tls *TLS, s uintptr, p uintptr) float64

func Xstrtof 

func Xstrtof(tls *TLS, s uintptr, p uintptr) float32

func Xstrtoimax 

func Xstrtoimax(tls *TLS, s uintptr, p uintptr, base int32) intmax_t

func Xstrtok 

func Xstrtok(tls *TLS, s uintptr, sep uintptr) uintptr

func Xstrtol 

func Xstrtol(tls *TLS, s uintptr, p uintptr, base int32) int64

func Xstrtold 

func Xstrtold(tls *TLS, s uintptr, p uintptr) float64

func Xstrtoll 

func Xstrtoll(tls *TLS, s uintptr, p uintptr, base int32) int64

func Xstrtoul 

func Xstrtoul(tls *TLS, s uintptr, p uintptr, base int32) uint64

func Xstrtoull 

func Xstrtoull(tls *TLS, s uintptr, p uintptr, base int32) uint64

func Xstrtoumax 

func Xstrtoumax(tls *TLS, s uintptr, p uintptr, base int32) uintmax_t
func Xsymlink(t *TLS, target, linkpath uintptr) int32

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

func Xsymlinkat 

func Xsymlinkat(t *TLS, target uintptr, newdirfd int32, linkpath uintptr) int32

int symlinkat(const char *target, int newdirfd, 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 Xtcsendbreak 

func Xtcsendbreak(t *TLS, fd, duration int32) int32

int tcsendbreak(int fd, int duration);

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 Xtmpfile 

func Xtmpfile(t *TLS) uintptr

FILE *tmpfile(void);

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 Xtrunc 

func Xtrunc(t *TLS, x float64) float64

func Xtzset 

func Xtzset(t *TLS)

void tzset (void);

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 Xungetc 

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

int ungetc(int c, FILE *stream); 

func Xunlink(t *TLS, pathname uintptr) int32

int unlink(const char *pathname);

func Xunlinkat 

func Xunlinkat(t *TLS, dirfd int32, pathname uintptr, flags int32) int32

int unlinkat(int dirfd, const char *pathname, int flags);

func Xunsetenv 

func Xunsetenv(t *TLS, name uintptr) int32

int unsetenv(const char *name);

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 Xutimensat 

func Xutimensat(t *TLS, dirfd int32, pathname, times uintptr, flags int32) int32

int utimensat(int dirfd, const char *pathname, const struct timespec times[2], int flags);

func Xutimes 

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

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

func Xuuid_copy 

func Xuuid_copy(t *TLS, dst, src uintptr)

void uuid_copy(uuid_t dst, uuid_t src);

func Xuuid_generate_random 

func Xuuid_generate_random(t *TLS, out uintptr)

void uuid_generate_random(uuid_t out);

func Xuuid_parse 

func Xuuid_parse(t *TLS, in uintptr, uu uintptr) int32

int uuid_parse( char *in, uuid_t uu);

func Xuuid_unparse 

func Xuuid_unparse(t *TLS, uu, out uintptr)

void uuid_unparse(uuid_t uu, char *out);

func Xvasprintf 

func Xvasprintf(t *TLS, strp, fmt, ap uintptr) int32

int vasprintf(char **strp, const char *fmt, va_list ap);

func Xvfprintf 

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

func Xvfscanf 

func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap va_list) int32

func Xvprintf 

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

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

func Xvsnprintf 

func Xvsnprintf(t *TLS, str uintptr, size types.Size_t, format, va uintptr) int32

int vsnprintf(char *str, size_t size, const char *format, va_list ap);

func Xvsprintf 

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

int vsprintf(char *str, const char *format, va_list ap);

func Xvsscanf 

func Xvsscanf(tls *TLS, s uintptr, fmt uintptr, ap va_list) int32

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 Xwcschr 

func Xwcschr(t *TLS, wcs uintptr, wc wchar_t) wchar_t

wchar_t *wcschr(const wchar_t *wcs, wchar_t wc);

func Xwctomb 

func Xwctomb(t *TLS, s uintptr, wc wchar_t) int32

int wctomb(char *s, wchar_t wc);

func Xwcwidth 

func Xwcwidth(t *TLS, c wchar_t) int32

int wcwidth(wchar_t c);

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);

func Xwritev 

func Xwritev(t *TLS, fd int32, iov uintptr, iovcnt int32) types.Ssize_t

ssize_t writev(int fd, const struct iovec *iov, int iovcnt);

Types

type DIR 

type DIR = __dirstream /* dirent.h:20:28 */

type FILE 

type FILE = _IO_FILE /* alltypes.h:320:25 */

type HEADER = struct {
	// contains filtered or unexported fields

} /* nameser.h:353:3 */

type Int128 

type Int128 mathutil.Int128

func Int128FromFloat32 

func Int128FromFloat32(n float32) Int128

func Int128FromFloat64 

func Int128FromFloat64(n float64) Int128

func Int128FromInt16 

func Int128FromInt16(n int16) Int128

func Int128FromInt32 

func Int128FromInt32(n int32) Int128

func Int128FromInt64 

func Int128FromInt64(n int64) Int128

func Int128FromInt8 

func Int128FromInt8(n int8) Int128

func Int128FromUint128 

func Int128FromUint128(n Uint128) Int128

func Int128FromUint16 

func Int128FromUint16(n uint16) Int128

func Int128FromUint32 

func Int128FromUint32(n uint32) Int128

func Int128FromUint64 

func Int128FromUint64(n uint64) Int128

func Int128FromUint8 

func Int128FromUint8(n uint8) Int128

func (Int128) Add 

func (n Int128) Add(m Int128) (r Int128)

func (Int128) And 

func (n Int128) And(v Int128) Int128

func (Int128) Cmp 

func (n Int128) Cmp(y Int128) int

func (Int128) Float32 

func (n Int128) Float32() float32

func (Int128) Float64 

func (n Int128) Float64() float64

func (Int128) Int16 

func (n Int128) Int16() int16

func (Int128) Int32 

func (n Int128) Int32() int32

func (Int128) Int64 

func (n Int128) Int64() int64

func (Int128) Int8 

func (n Int128) Int8() int8

func (*Int128) LValueDec 

func (n *Int128) LValueDec()

func (*Int128) LValueInc 

func (n *Int128) LValueInc()

func (*Int128) LValueShl 

func (n *Int128) LValueShl(c int32)

func (*Int128) LValueShr 

func (n *Int128) LValueShr(c int32)

func (Int128) Mul 

func (n Int128) Mul(m Int128) Int128

func (Int128) Neg 

func (n Int128) Neg() Int128

func (Int128) Or 

func (n Int128) Or(v Int128) Int128

func (Int128) Shl 

func (n Int128) Shl(c int32) (r Int128)

func (Int128) Shr 

func (n Int128) Shr(c int32) (r Int128)

func (Int128) Uint128 

func (n Int128) Uint128() (r Uint128)

func (Int128) Uint16 

func (n Int128) Uint16() uint16

func (Int128) Uint32 

func (n Int128) Uint32() uint32

func (Int128) Uint64 

func (n Int128) Uint64() uint64

func (Int128) Uint8 

func (n Int128) Uint8() uint8

func (Int128) Xor 

func (n Int128) Xor(v Int128) Int128

type PerfCounter 

type PerfCounter struct {
	// contains filtered or unexported fields
}

func NewPerfCounter 

func NewPerfCounter(labels []string) *PerfCounter

func (*PerfCounter) Clear 

func (c *PerfCounter) Clear()

func (*PerfCounter) Disable 

func (c *PerfCounter) Disable()

func (*PerfCounter) Enable 

func (c *PerfCounter) Enable()

func (*PerfCounter) Inc 

func (c *PerfCounter) Inc(n int)

func (*PerfCounter) IncN 

func (c *PerfCounter) IncN(n, m int)

func (*PerfCounter) String 

func (c *PerfCounter) String() string

type RawMem 

type RawMem [1<<50 - 1]byte

RawMem represents the biggest byte array the runtime can handle

type RawMem64 

type RawMem64 [unsafe.Sizeof(RawMem{}) / unsafe.Sizeof(uint64(0))]uint64

RawMem64 represents the biggest uint64 array the runtime can handle.

type StackCapture 

type StackCapture struct {
	sync.Mutex
	// contains filtered or unexported fields
}

func NewStackCapture 

func NewStackCapture(depth int) *StackCapture

func (*StackCapture) Clear 

func (c *StackCapture) Clear()

func (*StackCapture) Disable 

func (c *StackCapture) Disable()

func (*StackCapture) Enable 

func (c *StackCapture) Enable()

func (*StackCapture) Record 

func (c *StackCapture) Record()

func (*StackCapture) String 

func (c *StackCapture) String() string

type TLS 

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

Thread local storage.

func NewTLS 

func NewTLS() *TLS

func (*TLS) Alloc 

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

Alloc allocates n bytes of thread-local storage. It must be paired with a call to t.Free(n), using the same n. The order matters. This is ok: 

t.Alloc(11)
	t.Alloc(22)
	t.Free(22)
t.Free(11)

This is not correct: 

t.Alloc(11)
	t.Alloc(22)
	t.Free(11)
t.Free(22)

func (*TLS) Close 

func (t *TLS) Close()

Close frees the resources of t.

func (*TLS) Free 

func (t *TLS) Free(n int)

Free deallocates n bytes of thread-local storage. See TLS.Alloc for details on correct usage.

type Uint128 

type Uint128 mathutil.Uint128

func Uint128FromFloat32 

func Uint128FromFloat32(n float32) Uint128

func Uint128FromFloat64 

func Uint128FromFloat64(n float64) Uint128

func Uint128FromInt128 

func Uint128FromInt128(n Int128) Uint128

func Uint128FromInt16 

func Uint128FromInt16(n int16) Uint128

func Uint128FromInt32 

func Uint128FromInt32(n int32) Uint128

func Uint128FromInt64 

func Uint128FromInt64(n int64) (r Uint128)

func Uint128FromInt8 

func Uint128FromInt8(n int8) Uint128

func Uint128FromUint16 

func Uint128FromUint16(n uint16) Uint128

func Uint128FromUint32 

func Uint128FromUint32(n uint32) Uint128

func Uint128FromUint64 

func Uint128FromUint64(n uint64) Uint128

func Uint128FromUint8 

func Uint128FromUint8(n uint8) Uint128

func (Uint128) Add 

func (n Uint128) Add(m Uint128) (r Uint128)

func (Uint128) And 

func (n Uint128) And(m Uint128) Uint128

func (Uint128) Cmp 

func (n Uint128) Cmp(m Uint128) int

func (Uint128) Div 

func (n Uint128) Div(m Uint128) (r Uint128)

func (Uint128) Float32 

func (n Uint128) Float32() float32

func (Uint128) Float64 

func (n Uint128) Float64() float64

func (Uint128) Int128 

func (n Uint128) Int128() Int128

func (Uint128) Int16 

func (n Uint128) Int16() int16

func (Uint128) Int32 

func (n Uint128) Int32() int32

func (Uint128) Int64 

func (n Uint128) Int64() int64

func (Uint128) Int8 

func (n Uint128) Int8() int8

func (*Uint128) LValueShl 

func (n *Uint128) LValueShl(c int32)

func (*Uint128) LValueShr 

func (n *Uint128) LValueShr(c int32)

func (Uint128) Mul 

func (n Uint128) Mul(m Uint128) Uint128

func (Uint128) Or 

func (n Uint128) Or(m Uint128) Uint128

func (Uint128) Shl 

func (n Uint128) Shl(c int32) (r Uint128)

func (Uint128) Shr 

func (n Uint128) Shr(c int32) (r Uint128)

func (Uint128) Sub 

func (n Uint128) Sub(m Uint128) Uint128

func (Uint128) Uint16 

func (n Uint128) Uint16() uint16

func (Uint128) Uint32 

func (n Uint128) Uint32() uint32

func (Uint128) Uint64 

func (n Uint128) Uint64() uint64

func (Uint128) Uint8 

func (n Uint128) Uint8() uint8

func (Uint128) Xor 

func (n Uint128) Xor(m Uint128) Uint128

Source Files

View all Source files

Directories

Path Synopsis
honnef.co
go/netdb
Package netdb provides a Go interface for the protoent and servent structures as defined in netdb.h
 Package netdb provides a Go interface for the protoent and servent structures as defined in netdb.h
netinet
in
sys
random
socket
stat
types
vfs

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.