libc

package module
v1.16.12 Latest Latest
Warning

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

 Go to latest Published: Jun 28, 2022 License: BSD-3-Clause Imports: 54 Imported by: 137

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{}{}/* 517 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 added in v1.16.12 

func AssignAddComplex128(p *complex128, v complex128) complex128

func AssignAddComplex64 added in v1.16.12 

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 added in v1.16.12 

func AssignAddPtrComplex128(p uintptr, v complex128) complex128

func AssignAddPtrComplex64 added in v1.16.12 

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 added in v1.16.12 

func AssignComplex128(p *complex128, v complex128) complex128

func AssignComplex64 added in v1.16.12 

func AssignComplex64(p *complex64, v complex64) complex64

func AssignDivComplex128 added in v1.16.12 

func AssignDivComplex128(p *complex128, v complex128) complex128

func AssignDivComplex64 added in v1.16.12 

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 added in v1.16.12 

func AssignDivPtrComplex128(p uintptr, v complex128) complex128

func AssignDivPtrComplex64 added in v1.16.12 

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 added in v1.16.12 

func AssignMulComplex128(p *complex128, v complex128) complex128

func AssignMulComplex64 added in v1.16.12 

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 added in v1.16.12 

func AssignMulPtrComplex128(p uintptr, v complex128) complex128

func AssignMulPtrComplex64 added in v1.16.12 

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 added in v1.16.12 

func AssignPtrComplex128(p uintptr, v complex128) complex128

func AssignPtrComplex64 added in v1.16.12 

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 added in v1.16.12 

func AssignSubComplex128(p *complex128, v complex128) complex128

func AssignSubComplex64 added in v1.16.12 

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 added in v1.16.12 

func AssignSubPtrComplex128(p uintptr, v complex128) complex128

func AssignSubPtrComplex64 added in v1.16.12 

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 added in v1.9.1 

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 added in v1.7.7 

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

func AtomicAddFloat64 added in v1.7.7 

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

func AtomicAddInt32 added in v1.7.7 

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

func AtomicAddInt64 added in v1.7.7 

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

func AtomicAddUint32 added in v1.7.7 

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

func AtomicAddUint64 added in v1.7.7 

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

func AtomicAddUintptr added in v1.7.7 

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

func AtomicLoadFloat32 added in v1.7.7 

func AtomicLoadFloat32(addr *float32) (val float32)

func AtomicLoadFloat64 added in v1.7.7 

func AtomicLoadFloat64(addr *float64) (val float64)

func AtomicLoadInt32 added in v1.7.7 

func AtomicLoadInt32(addr *int32) (val int32)

func AtomicLoadInt64 added in v1.7.7 

func AtomicLoadInt64(addr *int64) (val int64)

func AtomicLoadNInt32 added in v1.7.0 

func AtomicLoadNInt32(ptr uintptr, memorder int32) int32

func AtomicLoadNInt64 added in v1.7.0 

func AtomicLoadNInt64(ptr uintptr, memorder int32) int64

func AtomicLoadNUint16 added in v1.7.0 

func AtomicLoadNUint16(ptr uintptr, memorder int16) uint16

func AtomicLoadNUint32 added in v1.7.0 

func AtomicLoadNUint32(ptr uintptr, memorder int32) uint32

func AtomicLoadNUint64 added in v1.7.0 

func AtomicLoadNUint64(ptr uintptr, memorder int32) uint64

func AtomicLoadNUintptr added in v1.7.0 

func AtomicLoadNUintptr(ptr uintptr, memorder int32) uintptr

func AtomicLoadPFloat32 added in v1.7.7 

func AtomicLoadPFloat32(addr uintptr) (val float32)

func AtomicLoadPFloat64 added in v1.7.7 

func AtomicLoadPFloat64(addr uintptr) (val float64)

func AtomicLoadPInt32 added in v1.7.7 

func AtomicLoadPInt32(addr uintptr) (val int32)

func AtomicLoadPInt64 added in v1.7.7 

func AtomicLoadPInt64(addr uintptr) (val int64)

func AtomicLoadPUint32 added in v1.7.7 

func AtomicLoadPUint32(addr uintptr) (val uint32)

func AtomicLoadPUint64 added in v1.7.7 

func AtomicLoadPUint64(addr uintptr) (val uint64)

func AtomicLoadPUintptr added in v1.7.7 

func AtomicLoadPUintptr(addr uintptr) (val uintptr)

func AtomicLoadUint32 added in v1.7.7 

func AtomicLoadUint32(addr *uint32) (val uint32)

func AtomicLoadUint64 added in v1.7.7 

func AtomicLoadUint64(addr *uint64) (val uint64)

func AtomicLoadUintptr added in v1.7.7 

func AtomicLoadUintptr(addr *uintptr) (val uintptr)

func AtomicStoreFloat32 added in v1.7.7 

func AtomicStoreFloat32(addr *float32, val float32)

func AtomicStoreFloat64 added in v1.7.7 

func AtomicStoreFloat64(addr *float64, val float64)

func AtomicStoreInt32 added in v1.7.7 

func AtomicStoreInt32(addr *int32, val int32)

func AtomicStoreInt64 added in v1.7.7 

func AtomicStoreInt64(addr *int64, val int64)

func AtomicStoreNInt32 added in v1.7.0 

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

func AtomicStoreNInt64 added in v1.7.0 

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

func AtomicStoreNUint16 added in v1.7.0 

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

func AtomicStoreNUint32 added in v1.7.0 

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

func AtomicStoreNUint64 added in v1.7.0 

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

func AtomicStoreNUintptr added in v1.7.0 

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

func AtomicStorePFloat32 added in v1.7.7 

func AtomicStorePFloat32(addr uintptr, val float32)

func AtomicStorePFloat64 added in v1.7.7 

func AtomicStorePFloat64(addr uintptr, val float64)

func AtomicStorePInt32 added in v1.7.7 

func AtomicStorePInt32(addr uintptr, val int32)

func AtomicStorePInt64 added in v1.7.7 

func AtomicStorePInt64(addr uintptr, val int64)

func AtomicStorePUint32 added in v1.7.7 

func AtomicStorePUint32(addr uintptr, val uint32)

func AtomicStorePUint64 added in v1.7.7 

func AtomicStorePUint64(addr uintptr, val uint64)

func AtomicStorePUintptr added in v1.7.7 

func AtomicStorePUintptr(addr uintptr, val uintptr)

func AtomicStoreUint32 added in v1.7.7 

func AtomicStoreUint32(addr *uint32, val uint32)

func AtomicStoreUint64 added in v1.7.7 

func AtomicStoreUint64(addr *uint64, val uint64)

func AtomicStoreUintptr added in v1.7.7 

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 CString 

func CString(s string) (uintptr, error)

func Complex128 added in v1.16.12 

func Complex128(n complex128) complex128

func Complex128FromComplex128 added in v1.16.12 

func Complex128FromComplex128(n complex128) complex128

func Complex128FromComplex64 added in v1.16.12 

func Complex128FromComplex64(n complex64) complex128

func Complex128FromFloat32 added in v1.16.12 

func Complex128FromFloat32(n float32) complex128

func Complex128FromFloat64 added in v1.16.12 

func Complex128FromFloat64(n float64) complex128

func Complex128FromInt16 added in v1.16.12 

func Complex128FromInt16(n int16) complex128

func Complex128FromInt32 added in v1.16.12 

func Complex128FromInt32(n int32) complex128

func Complex128FromInt64 added in v1.16.12 

func Complex128FromInt64(n int64) complex128

func Complex128FromInt8 added in v1.16.12 

func Complex128FromInt8(n int8) complex128

func Complex128FromUint16 added in v1.16.12 

func Complex128FromUint16(n uint16) complex128

func Complex128FromUint32 added in v1.16.12 

func Complex128FromUint32(n uint32) complex128

func Complex128FromUint64 added in v1.16.12 

func Complex128FromUint64(n uint64) complex128

func Complex128FromUint8 added in v1.16.12 

func Complex128FromUint8(n uint8) complex128

func Complex128FromUintptr added in v1.16.12 

func Complex128FromUintptr(n uintptr) complex128

func Complex64 added in v1.16.12 

func Complex64(n complex64) complex64

func Complex64FromComplex128 added in v1.16.12 

func Complex64FromComplex128(n complex128) complex64

func Complex64FromComplex64 added in v1.16.12 

func Complex64FromComplex64(n complex64) complex64

func Complex64FromFloat32 added in v1.16.12 

func Complex64FromFloat32(n float32) complex64

func Complex64FromFloat64 added in v1.16.12 

func Complex64FromFloat64(n float64) complex64

func Complex64FromInt16 added in v1.16.12 

func Complex64FromInt16(n int16) complex64

func Complex64FromInt32 added in v1.16.12 

func Complex64FromInt32(n int32) complex64

func Complex64FromInt64 added in v1.16.12 

func Complex64FromInt64(n int64) complex64

func Complex64FromInt8 added in v1.16.12 

func Complex64FromInt8(n int8) complex64

func Complex64FromUint16 added in v1.16.12 

func Complex64FromUint16(n uint16) complex64

func Complex64FromUint32 added in v1.16.12 

func Complex64FromUint32(n uint32) complex64

func Complex64FromUint64 added in v1.16.12 

func Complex64FromUint64(n uint64) complex64

func Complex64FromUint8 added in v1.16.12 

func Complex64FromUint8(n uint8) complex64

func Complex64FromUintptr added in v1.16.12 

func Complex64FromUintptr(n uintptr) complex64

func Cover 

func Cover()

func CoverC added in v1.2.0 

func CoverC(s string)

func CoverCReport added in v1.2.0 

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 added in v1.7.11 

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 added in v1.16.12 

func Float32FromComplex128(n complex128) float32

func Float32FromComplex64 added in v1.16.12 

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 added in v1.16.12 

func Float64FromComplex128(n complex128) float64

func Float64FromComplex64 added in v1.16.12 

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 added in v1.2.0 

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 added in v1.16.12 

func Int16FromComplex128(n complex128) int16

func Int16FromComplex64 added in v1.16.12 

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 added in v1.16.12 

func Int32FromComplex128(n complex128) int32

func Int32FromComplex64 added in v1.16.12 

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 added in v1.16.12 

func Int64FromComplex128(n complex128) int64

func Int64FromComplex64 added in v1.16.12 

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 added in v1.16.12 

func Int8FromComplex128(n complex128) int8

func Int8FromComplex64 added in v1.16.12 

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 added in v1.7.1 

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 added in v1.7.1 

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 added in v1.10.0 

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 added in v1.10.0 

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 added in v1.7.6 

func PostDecAtomicInt32(p *int32, d int32) int32

func PostDecAtomicInt64 added in v1.7.6 

func PostDecAtomicInt64(p *int64, d int64) int64

func PostDecAtomicUint32 added in v1.7.6 

func PostDecAtomicUint32(p *uint32, d uint32) uint32

func PostDecAtomicUint64 added in v1.7.6 

func PostDecAtomicUint64(p *uint64, d uint64) uint64

func PostDecAtomicUintptr added in v1.7.6 

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 added in v1.16.12 

func PostDecComplex128(p *complex128, d complex128) complex128

func PostDecComplex64 added in v1.16.12 

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 added in v1.7.6 

func PostIncAtomicInt32(p *int32, d int32) int32

func PostIncAtomicInt64 added in v1.7.6 

func PostIncAtomicInt64(p *int64, d int64) int64

func PostIncAtomicUint32 added in v1.7.6 

func PostIncAtomicUint32(p *uint32, d uint32) uint32

func PostIncAtomicUint64 added in v1.7.6 

func PostIncAtomicUint64(p *uint64, d uint64) uint64

func PostIncAtomicUintptr added in v1.7.6 

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 added in v1.16.12 

func PostIncComplex128(p *complex128, d complex128) complex128

func PostIncComplex64 added in v1.16.12 

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 added in v1.7.6 

func PreDecAtomicInt32(p *int32, d int32) int32

func PreDecAtomicInt64 added in v1.7.6 

func PreDecAtomicInt64(p *int64, d int64) int64

func PreDecAtomicUint32 added in v1.7.6 

func PreDecAtomicUint32(p *uint32, d uint32) uint32

func PreDecAtomicUint64 added in v1.7.6 

func PreDecAtomicUint64(p *uint64, d uint64) uint64

func PreDecAtomicUintptr added in v1.7.6 

func PreDecAtomicUintptr(p *uintptr, d uintptr) uintptr

func PreDecComplex128 added in v1.16.12 

func PreDecComplex128(p *complex128, d complex128) complex128

func PreDecComplex64 added in v1.16.12 

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 added in v1.7.6 

func PreIncAtomicInt32(p *int32, d int32) int32

func PreIncAtomicInt64 added in v1.7.6 

func PreIncAtomicInt64(p *int64, d int64) int64

func PreIncAtomicUint32 added in v1.7.6 

func PreIncAtomicUint32(p *uint32, d uint32) uint32

func PreIncAtomicUint64 added in v1.7.6 

func PreIncAtomicUint64(p *uint64, d uint64) uint64

func PreIncAtomicUintptr added in v1.7.6 

func PreIncAtomicUintptr(p *uintptr, d uintptr) uintptr

func PreIncComplex128 added in v1.16.12 

func PreIncComplex128(p *complex128, d complex128) complex128

func PreIncComplex64 added in v1.16.12 

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 added in v1.1.1 

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 added in v1.16.12 

func Uint16FromComplex128(n complex128) uint16

func Uint16FromComplex64 added in v1.16.12 

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 added in v1.16.12 

func Uint32FromComplex128(n complex128) uint32

func Uint32FromComplex64 added in v1.16.12 

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 added in v1.16.12 

func Uint64FromComplex128(n complex128) uint64

func Uint64FromComplex64 added in v1.16.12 

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 added in v1.16.12 

func Uint8FromComplex128(n complex128) uint8

func Uint8FromComplex64 added in v1.16.12 

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 added in v1.16.12 

func UintptrFromComplex128(n complex128) uintptr

func UintptrFromComplex64 added in v1.16.12 

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 added in v1.7.1 

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 added in v1.11.85 

func Watch()

func WatchDelete added in v1.11.85 

func WatchDelete(p uintptr)

func WatchFloat32 added in v1.11.85 

func WatchFloat32(p uintptr, msg string)

func WatchFloat64 added in v1.11.85 

func WatchFloat64(p uintptr, msg string)

func WatchInt16 added in v1.11.85 

func WatchInt16(p uintptr, msg string)

func WatchInt32 added in v1.11.85 

func WatchInt32(p uintptr, msg string)

func WatchInt64 added in v1.11.85 

func WatchInt64(p uintptr, msg string)

func WatchInt8 added in v1.11.85 

func WatchInt8(p uintptr, msg string)

func WatchPtr added in v1.11.85 

func WatchPtr(p uintptr, msg string)

func WatchUint16 added in v1.11.85 

func WatchUint16(p uintptr, msg string)

func WatchUint32 added in v1.11.85 

func WatchUint32(p uintptr, msg string)

func WatchUint64 added in v1.11.85 

func WatchUint64(p uintptr, msg string)

func WatchUint8 added in v1.11.85 

func WatchUint8(p uintptr, msg string)

func X_IO_putc added in v1.3.0 

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

int _IO_putc(int __c, _IO_FILE *__fp);

func X___errno_location added in v1.1.1 

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 added in v1.7.0 

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 added in v1.7.0 

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 added in v1.7.0 

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 added in v1.7.0 

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 added in v1.7.0 

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 added in v1.7.0 

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 added in v1.7.0 

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 added in v1.7.0 

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 added in v1.7.7 

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 added in v1.5.0 

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 added in v1.5.0 

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 added in v1.5.0 

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 added in v1.5.0 

func X__builtin_bswap16(t *TLS, x uint16) uint16

uint16_t __builtin_bswap16 (uint32_t x)

func X__builtin_bswap32 added in v1.5.0 

func X__builtin_bswap32(t *TLS, x uint32) uint32

uint32_t __builtin_bswap32 (uint32_t x)

func X__builtin_bswap64 added in v1.5.0 

func X__builtin_bswap64(t *TLS, x uint64) uint64

uint64_t __builtin_bswap64 (uint64_t x)

func X__builtin_bzero added in v1.11.100 

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

func X__builtin_clz added in v1.11.27 

func X__builtin_clz(t *TLS, n uint32) int32

func X__builtin_clzl added in v1.11.27 

func X__builtin_clzl(t *TLS, n ulong) int32

func X__builtin_clzll added in v1.7.0 

func X__builtin_clzll(t *TLS, n uint64) int32

func X__builtin_constant_p_impl added in v1.7.0 

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 added in v1.11.17 

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 added in v1.11.105 

func X__builtin_fabsf(t *TLS, x float32) float32

func X__builtin_fabsl added in v1.11.105 

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 added in v1.11.24 

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

func X__builtin_huge_val added in v1.7.0 

func X__builtin_huge_val(t *TLS) float64

func X__builtin_huge_valf added in v1.7.0 

func X__builtin_huge_valf(t *TLS) float32

func X__builtin_inf added in v1.7.0 

func X__builtin_inf(t *TLS) float64

func X__builtin_inff added in v1.7.0 

func X__builtin_inff(t *TLS) float32

func X__builtin_infl added in v1.11.17 

func X__builtin_infl(t *TLS) float64

func X__builtin_isnan added in v1.7.0 

func X__builtin_isnan(t *TLS, x float64) int32

func X__builtin_isunordered added in v1.12.0 

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

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 added in v1.7.0 

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 added in v1.5.0 

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 added in v1.7.5 

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 added in v1.7.5 

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 added in v1.11.17 

func X__builtin_nan(t *TLS, s uintptr) float64

func X__builtin_nanf added in v1.7.0 

func X__builtin_nanf(t *TLS, s uintptr) float32

func X__builtin_nanl added in v1.11.17 

func X__builtin_nanl(t *TLS, s uintptr) float64

func X__builtin_object_size added in v1.7.0 

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 added in v1.7.8 

func X__builtin_popcount(t *TLS, x uint32) int32

int __builtin_popcount (unsigned int x)

func X__builtin_popcountl added in v1.11.25 

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 added in v1.5.0 

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 added in v1.11.19 

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

func X__ccgo_getMutexType added in v1.9.0 

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 added in v1.9.0 

func X__ccgo_pthreadAttrGetDetachState(tls *TLS, a uintptr) int32

func X__ccgo_pthreadMutexattrGettype added in v1.9.0 

func X__ccgo_pthreadMutexattrGettype(tls *TLS, a uintptr) int32

func X__ccgo_sqlite3_log added in v1.2.0 

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 added in v1.7.7 

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 added in v1.7.7 

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 added in v1.7.0 

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

func X__fpclassify added in v1.7.0 

func X__fpclassify(tls *TLS, x float64) int32

func X__fpclassifyf added in v1.7.0 

func X__fpclassifyf(tls *TLS, x float32) int32

func X__fpclassifyl added in v1.7.0 

func X__fpclassifyl(tls *TLS, x float64) int32

func X__h_errno_location added in v1.1.1 

func X__h_errno_location(tls *TLS) uintptr

func X__inet_aton added in v1.1.1 

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

func X__intscan added in v1.1.1 

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

func X__isalnum_l added in v1.1.1 

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

func X__isalpha_l added in v1.1.1 

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

func X__isdigit_l added in v1.1.1 

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

func X__islower_l added in v1.7.0 

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 added in v1.7.0 

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

func X__isupper_l added in v1.7.0 

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

func X__isxdigit_l added in v1.7.0 

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

func X__lockfile added in v1.7.12 

func X__lockfile(tls *TLS, f uintptr) int32

func X__lookup_ipliteral added in v1.1.1 

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

func X__lookup_name added in v1.1.1 

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

func X__lookup_serv added in v1.1.1 

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

func X__shgetc added in v1.1.1 

func X__shgetc(tls *TLS, f uintptr) int32

func X__shlim added in v1.1.1 

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

func X__strncasecmp_l added in v1.7.9 

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

func X__sync_add_and_fetch_uint32 added in v1.11.34 

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 added in v1.11.34 

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 added in v1.9.0 

func X__sync_synchronize(t *TLS)

__sync_synchronize();

func X__syscall1 added in v1.1.1 

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

func X__syscall3 added in v1.1.1 

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

func X__syscall4 added in v1.7.12 

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

func X__toread added in v1.1.1 

func X__toread(tls *TLS, f uintptr) int32

func X__toread_needs_stdio_exit added in v1.1.1 

func X__toread_needs_stdio_exit(tls *TLS)

func X__uflow added in v1.1.1 

func X__uflow(tls *TLS, f uintptr) int32

func X__unlockfile added in v1.7.12 

func X__unlockfile(tls *TLS, f uintptr)

func X_exit 

func X_exit(_ *TLS, status int32)

void _exit(int status);

func X_longjmp added in v1.11.28 

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

void _longjmp(jmp_buf env, int val);

func X_obstack_begin added in v1.7.0 

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 added in v1.7.0 

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

extern void _obstack_newchunk(struct obstack *, int);

func X_setjmp added in v1.11.28 

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 added in v1.8.1 

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 added in v1.8.1 

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 added in v1.8.1 

func Xatanh(t *TLS, x float64) float64

func Xatexit added in v1.7.0 

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 added in v1.14.5 

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

func Xbzero added in v1.11.100 

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 added in v1.7.8 

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 added in v1.7.7 

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 added in v1.7.0 

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 added in v1.7.0 

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 added in v1.7.9 

func Xctime(t *TLS, timep uintptr) uintptr

char *ctime(const time_t *timep);

func Xctime_r added in v1.9.1 

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 added in v1.14.10 

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

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

func Xendpwent added in v1.7.9 

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 added in v1.7.0 

func Xfabsl(tls *TLS, x float64) float64

func Xfaccessat added in v1.14.10 

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 added in v1.14.10 

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 added in v1.14.10 

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 added in v1.7.0 

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 added in v1.7.0 

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 added in v1.11.28 

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 added in v1.2.0 

func Xfts64_close(t *TLS, ftsp uintptr) int32

int fts_close(FTS *ftsp);

func Xfts64_open added in v1.2.0 

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 added in v1.2.0 

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 added in v1.7.0 

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 added in v1.7.8 

func Xgetegid(t *TLS) types.Gid_t

gid_t getegid(void);

func Xgetentropy added in v1.11.24 

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 added in v1.7.8 

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 added in v1.8.1 

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 added in v1.8.1 

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 added in v1.1.1 

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 added in v1.1.1 

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

func Xgethostbyname2_r added in v1.1.1 

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

func Xgethostbyname_r added in v1.8.1 

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

func Xgethostname added in v1.7.7 

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 added in v1.7.8 

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 added in v1.7.8 

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 added in v1.11.29 

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 added in v1.7.8 

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

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

func Xgetresuid added in v1.7.8 

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 added in v1.2.0 

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 added in v1.1.1 

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

func Xinet_pton added in v1.1.1 

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

func Xinitstate added in v1.11.102 

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 added in v1.7.8 

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 added in v1.1.1 

func Xisalnum(tls *TLS, c int32) int32

func Xisalpha added in v1.1.1 

func Xisalpha(tls *TLS, c int32) int32

func Xisascii added in v1.11.101 

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 added in v1.1.1 

func Xisdigit(tls *TLS, c int32) int32

func Xislower added in v1.7.0 

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 added in v1.7.0 

func Xisprint(tls *TLS, c int32) int32

func Xisupper added in v1.7.0 

func Xisupper(tls *TLS, c int32) int32

func Xiswalnum added in v1.11.35 

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

int iswalnum(wint_t wc);

func Xiswspace added in v1.11.35 

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

int iswspace(wint_t wc);

func Xisxdigit added in v1.7.0 

func Xisxdigit(tls *TLS, c int32) int32

func Xkill added in v1.7.7 

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 added in v1.14.10 

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 Xlocaleconv added in v1.11.29 

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 Xlongjmp added in v1.11.27 

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

void longjmp(jmp_buf env, int val);

func Xlrand48 added in v1.7.7 

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 added in v1.7.7 

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

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

func Xmbrtowc added in v1.7.12 

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

func Xmbsinit added in v1.7.12 

func Xmbsinit(tls *TLS, st uintptr) int32

func Xmbstowcs added in v1.7.7 

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 added in v1.7.7 

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 added in v1.14.10 

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 added in v1.14.10 

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 added in v1.11.28 

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 added in v1.2.0 

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 added in v1.2.0 

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 added in v1.7.0 

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 added in v1.7.0 

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 added in v1.7.0 

func Xnanf(tls *TLS, s uintptr) float32

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 added in v1.7.0 

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

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

func Xobstack_vprintf added in v1.7.0 

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 added in v1.14.10 

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 added in v1.7.7 

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 added in v1.7.7 

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

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

func Xpause added in v1.7.7 

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 added in v1.14.10 

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

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

func Xpoll added in v1.7.7 

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 added in v1.7.7 

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 added in v1.7.7 

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 added in v1.8.1 

func Xpthread_attr_destroy(t *TLS, pAttr uintptr) int32

int pthread_attr_destroy(pthread_attr_t *attr);

func Xpthread_attr_getdetachstate added in v1.9.0 

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

func Xpthread_attr_init added in v1.8.1 

func Xpthread_attr_init(t *TLS, pAttr uintptr) int32

int pthread_attr_init(pthread_attr_t *attr);

func Xpthread_attr_setdetachstate added in v1.8.1 

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

func Xpthread_attr_setscope added in v1.8.1 

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 added in v1.8.1 

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 added in v1.7.7 

func Xpthread_cond_broadcast(t *TLS, pCond uintptr) int32

int pthread_cond_broadcast(pthread_cond_t *cond);

func Xpthread_cond_destroy added in v1.7.7 

func Xpthread_cond_destroy(t *TLS, pCond uintptr) int32

int pthread_cond_destroy(pthread_cond_t *cond);

func Xpthread_cond_init added in v1.7.7 

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 added in v1.7.7 

func Xpthread_cond_signal(t *TLS, pCond uintptr) int32

int pthread_cond_signal(pthread_cond_t *cond);

func Xpthread_cond_timedwait added in v1.8.1 

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 added in v1.7.7 

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 added in v1.7.7 

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 added in v1.7.7 

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

int pthread_detach(pthread_t thread);

func Xpthread_equal added in v1.7.8 

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

int pthread_equal(pthread_t t1, pthread_t t2);

func Xpthread_exit added in v1.8.1 

func Xpthread_exit(t *TLS, value uintptr)

void pthread_exit(void *value_ptr);

func Xpthread_getspecific added in v1.8.1 

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

void *pthread_getspecific(pthread_key_t key);

func Xpthread_join added in v1.8.1 

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 added in v1.8.1 

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 added in v1.8.1 

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

int pthread_key_delete(pthread_key_t key);

func Xpthread_mutex_destroy added in v1.7.7 

func Xpthread_mutex_destroy(t *TLS, pMutex uintptr) int32

int pthread_mutex_destroy(pthread_mutex_t *mutex);

func Xpthread_mutex_init added in v1.7.7 

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 added in v1.7.7 

func Xpthread_mutex_lock(t *TLS, pMutex uintptr) int32

int pthread_mutex_lock(pthread_mutex_t *mutex);

func Xpthread_mutex_trylock added in v1.7.7 

func Xpthread_mutex_trylock(t *TLS, pMutex uintptr) int32

int pthread_mutex_trylock(pthread_mutex_t *mutex);

func Xpthread_mutex_unlock added in v1.7.7 

func Xpthread_mutex_unlock(t *TLS, pMutex uintptr) int32

int pthread_mutex_unlock(pthread_mutex_t *mutex);

func Xpthread_mutexattr_destroy added in v1.9.0 

func Xpthread_mutexattr_destroy(tls *TLS, a uintptr) int32

func Xpthread_mutexattr_init added in v1.9.0 

func Xpthread_mutexattr_init(tls *TLS, a uintptr) int32

func Xpthread_mutexattr_settype added in v1.9.0 

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

func Xpthread_self added in v1.7.8 

func Xpthread_self(t *TLS) pthread.Pthread_t

pthread_t pthread_self(void);

func Xpthread_setspecific added in v1.8.1 

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 added in v1.7.0 

func Xputs(t *TLS, s uintptr) int32

int puts(const char *s);

func Xpwrite added in v1.11.6 

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 added in v1.7.0 

func Xrand_r(tls *TLS, seed uintptr) int32

func Xrandom added in v1.7.0 

func Xrandom(t *TLS) long

long int random(void);

func Xrandom_r added in v1.7.8 

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 added in v1.14.10 

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 added in v1.7.7 

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 added in v1.11.25 

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 added in v1.7.7 

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 added in v1.7.7 

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 added in v1.7.7 

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 added in v1.14.10 

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 added in v1.11.101 

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

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

func Xrint added in v1.11.5 

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 added in v1.7.0 

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

func Xscalbnl added in v1.7.0 

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

func Xsched_yield added in v1.9.0 

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 added in v1.7.7 

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 added in v1.7.7 

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 added in v1.7.0 

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

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

func Xsetenv added in v1.7.7 

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

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

func Xsetjmp added in v1.11.27 

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 added in v1.2.0 

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

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

func Xsetsid added in v1.7.7 

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 added in v1.11.102 

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 added in v1.7.8 

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

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

func Xshmctl added in v1.7.8 

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

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

func Xshmdt added in v1.7.8 

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 added in v1.7.7 

func Xsrand48(t *TLS, seedval long)

void srand48(long int seedval);

func Xsscanf added in v1.7.0 

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 added in v1.11.29 

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 added in v1.7.0 

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

func Xstrlcpy added in v1.7.0 

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 added in v1.7.9 

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

func Xstrncat added in v1.7.0 

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 added in v1.1.1 

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 added in v1.1.1 

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 added in v1.7.0 

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

func Xstrtof added in v1.7.0 

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

func Xstrtoimax added in v1.1.1 

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

func Xstrtok added in v1.7.0 

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

func Xstrtol 

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

func Xstrtold added in v1.7.0 

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

func Xstrtoll added in v1.1.1 

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 added in v1.1.1 

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

func Xstrtoumax added in v1.1.1 

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 added in v1.14.10 

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 added in v1.7.7 

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 added in v1.11.43 

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 added in v1.8.1 

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 added in v1.7.0 

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 added in v1.14.10 

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

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

func Xunsetenv added in v1.7.7 

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 added in v1.14.10 

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 added in v1.11.28 

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

void uuid_copy(uuid_t dst, uuid_t src);

func Xuuid_generate_random added in v1.7.7 

func Xuuid_generate_random(t *TLS, out uintptr)

void uuid_generate_random(uuid_t out);

func Xuuid_parse added in v1.7.7 

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

int uuid_parse( char *in, uuid_t uu);

func Xuuid_unparse added in v1.7.7 

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

void uuid_unparse(uuid_t uu, char *out);

func Xvasprintf added in v1.7.0 

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 added in v1.7.12 

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 added in v1.7.0 

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 added in v1.7.0 

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

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

func Xvsscanf added in v1.7.12 

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 added in v1.7.7 

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

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

func Xwctomb added in v1.7.7 

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

int wctomb(char *s, wchar_t wc);

func Xwcwidth added in v1.7.7 

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 added in v1.7.7 

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 added in v1.1.1 

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

type FILE added in v1.1.1 

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

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

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

type Int128 added in v1.7.5 

type Int128 mathutil.Int128

func Int128FromFloat32 added in v1.7.5 

func Int128FromFloat32(n float32) Int128

func Int128FromFloat64 added in v1.7.5 

func Int128FromFloat64(n float64) Int128

func Int128FromInt16 added in v1.7.5 

func Int128FromInt16(n int16) Int128

func Int128FromInt32 added in v1.7.5 

func Int128FromInt32(n int32) Int128

func Int128FromInt64 added in v1.7.5 

func Int128FromInt64(n int64) Int128

func Int128FromInt8 added in v1.7.5 

func Int128FromInt8(n int8) Int128

func Int128FromUint128 added in v1.7.5 

func Int128FromUint128(n Uint128) Int128

func Int128FromUint16 added in v1.7.5 

func Int128FromUint16(n uint16) Int128

func Int128FromUint32 added in v1.7.5 

func Int128FromUint32(n uint32) Int128

func Int128FromUint64 added in v1.7.5 

func Int128FromUint64(n uint64) Int128

func Int128FromUint8 added in v1.7.5 

func Int128FromUint8(n uint8) Int128

func (Int128) Add added in v1.7.5 

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

func (Int128) And added in v1.7.5 

func (n Int128) And(v Int128) Int128

func (Int128) Cmp added in v1.7.5 

func (n Int128) Cmp(y Int128) int

func (Int128) Float32 added in v1.7.5 

func (n Int128) Float32() float32

func (Int128) Float64 added in v1.7.5 

func (n Int128) Float64() float64

func (Int128) Int16 added in v1.7.5 

func (n Int128) Int16() int16

func (Int128) Int32 added in v1.7.5 

func (n Int128) Int32() int32

func (Int128) Int64 added in v1.7.5 

func (n Int128) Int64() int64

func (Int128) Int8 added in v1.7.5 

func (n Int128) Int8() int8

func (*Int128) LValueDec added in v1.7.5 

func (n *Int128) LValueDec()

func (*Int128) LValueInc added in v1.7.5 

func (n *Int128) LValueInc()

func (*Int128) LValueShl added in v1.7.5 

func (n *Int128) LValueShl(c int32)

func (*Int128) LValueShr added in v1.7.5 

func (n *Int128) LValueShr(c int32)

func (Int128) Mul added in v1.7.5 

func (n Int128) Mul(m Int128) Int128

func (Int128) Neg added in v1.7.5 

func (n Int128) Neg() Int128

func (Int128) Or added in v1.7.5 

func (n Int128) Or(v Int128) Int128

func (Int128) Shl added in v1.7.5 

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

func (Int128) Shr added in v1.7.5 

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

func (Int128) Uint128 added in v1.7.5 

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

func (Int128) Uint16 added in v1.7.5 

func (n Int128) Uint16() uint16

func (Int128) Uint32 added in v1.7.5 

func (n Int128) Uint32() uint32

func (Int128) Uint64 added in v1.7.5 

func (n Int128) Uint64() uint64

func (Int128) Uint8 added in v1.7.5 

func (n Int128) Uint8() uint8

func (Int128) Xor added in v1.7.5 

func (n Int128) Xor(v Int128) Int128

type RawMem 

type RawMem [1<<50 - 1]byte

RawMem represents the biggest byte array the runtime can handle

type RawMem64 added in v1.7.0 

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

RawMem64 represents the biggest uint64 array the runtime can handle.

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 added in v1.7.5 

type Uint128 mathutil.Uint128

func Uint128FromFloat32 added in v1.7.5 

func Uint128FromFloat32(n float32) Uint128

func Uint128FromFloat64 added in v1.7.5 

func Uint128FromFloat64(n float64) Uint128

func Uint128FromInt128 added in v1.7.5 

func Uint128FromInt128(n Int128) Uint128

func Uint128FromInt16 added in v1.7.5 

func Uint128FromInt16(n int16) Uint128

func Uint128FromInt32 added in v1.7.5 

func Uint128FromInt32(n int32) Uint128

func Uint128FromInt64 added in v1.7.5 

func Uint128FromInt64(n int64) (r Uint128)

func Uint128FromInt8 added in v1.7.5 

func Uint128FromInt8(n int8) Uint128

func Uint128FromUint16 added in v1.7.5 

func Uint128FromUint16(n uint16) Uint128

func Uint128FromUint32 added in v1.7.5 

func Uint128FromUint32(n uint32) Uint128

func Uint128FromUint64 added in v1.7.5 

func Uint128FromUint64(n uint64) Uint128

func Uint128FromUint8 added in v1.7.5 

func Uint128FromUint8(n uint8) Uint128

func (Uint128) Add added in v1.7.5 

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

func (Uint128) And added in v1.7.5 

func (n Uint128) And(m Uint128) Uint128

func (Uint128) Cmp added in v1.7.5 

func (n Uint128) Cmp(m Uint128) int

func (Uint128) Div added in v1.7.5 

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

func (Uint128) Float32 added in v1.7.5 

func (n Uint128) Float32() float32

func (Uint128) Float64 added in v1.7.5 

func (n Uint128) Float64() float64

func (Uint128) Int128 added in v1.7.5 

func (n Uint128) Int128() Int128

func (Uint128) Int16 added in v1.7.5 

func (n Uint128) Int16() int16

func (Uint128) Int32 added in v1.7.5 

func (n Uint128) Int32() int32

func (Uint128) Int64 added in v1.7.5 

func (n Uint128) Int64() int64

func (Uint128) Int8 added in v1.7.5 

func (n Uint128) Int8() int8

func (*Uint128) LValueShl added in v1.7.5 

func (n *Uint128) LValueShl(c int32)

func (*Uint128) LValueShr added in v1.7.5 

func (n *Uint128) LValueShr(c int32)

func (Uint128) Mul added in v1.7.5 

func (n Uint128) Mul(m Uint128) Uint128

func (Uint128) Or added in v1.7.5 

func (n Uint128) Or(m Uint128) Uint128

func (Uint128) Shl added in v1.7.5 

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

func (Uint128) Shr added in v1.7.5 

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

func (Uint128) Sub added in v1.7.5 

func (n Uint128) Sub(m Uint128) Uint128

func (Uint128) Uint16 added in v1.7.5 

func (n Uint128) Uint16() uint16

func (Uint128) Uint32 added in v1.7.5 

func (n Uint128) Uint32() uint32

func (Uint128) Uint64 added in v1.7.5 

func (n Uint128) Uint64() uint64

func (Uint128) Uint8 added in v1.7.5 

func (n Uint128) Uint8() uint8

func (Uint128) Xor added in v1.7.5 

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 A pure Go implementation is used by parsing /etc/protocols and /etc/services All return values are pointers that point to the entries in the original list of protocols and services.
 Package netdb provides a Go interface for the protoent and servent structures as defined in netdb.h A pure Go implementation is used by parsing /etc/protocols and /etc/services All return values are pointers that point to the entries in the original list of protocols and services.
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.