libc

package module
Version: 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: 59

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