gtsocial-umbx

musl_windows_amd64.go (31549B)

---

 // Code generated by 'ccgo -D__environ=environ -export-externs X -hide __syscall0,__syscall1,__syscall2,__syscall3,__syscall4,__syscall5,__syscall6 -nostdinc -nostdlib -o ../musl_windows_amd64.go -pkgname libc -static-locals-prefix _s -Iarch\x86_64 -Iarch/generic -Iobj/src/internal -Isrc/include -Isrc/internal -Iobj/include -Iinclude copyright.c src/ctype/isalnum.c src/ctype/isalpha.c src/ctype/isdigit.c src/ctype/islower.c src/ctype/isprint.c src/ctype/isspace.c src/ctype/isxdigit.c src/env/putenv.c src/env/setenv.c src/env/unsetenv.c src/multibyte/wcrtomb.c src/multibyte/wcsrtombs.c src/multibyte/wcstombs.c src/stdlib/bsearch.c src/string/strchrnul.c src/string/strdup.c', DO NOT EDIT.
 
 package libc
 
 import (
 	"math"
 	"reflect"
 	"sync/atomic"
 	"unsafe"
 )
 
 var _ = math.Pi
 var _ reflect.Kind
 var _ atomic.Value
 var _ unsafe.Pointer
 
 // musl as a whole is licensed under the following standard MIT license:
 //
 // ----------------------------------------------------------------------
 // Copyright © 2005-2020 Rich Felker, et al.
 //
 // Permission is hereby granted, free of charge, to any person obtaining
 // a copy of this software and associated documentation files (the
 // "Software"), to deal in the Software without restriction, including
 // without limitation the rights to use, copy, modify, merge, publish,
 // distribute, sublicense, and/or sell copies of the Software, and to
 // permit persons to whom the Software is furnished to do so, subject to
 // the following conditions:
 //
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 // ----------------------------------------------------------------------
 //
 // Authors/contributors include:
 //
 // A. Wilcox
 // Ada Worcester
 // Alex Dowad
 // Alex Suykov
 // Alexander Monakov
 // Andre McCurdy
 // Andrew Kelley
 // Anthony G. Basile
 // Aric Belsito
 // Arvid Picciani
 // Bartosz Brachaczek
 // Benjamin Peterson
 // Bobby Bingham
 // Boris Brezillon
 // Brent Cook
 // Chris Spiegel
 // Clément Vasseur
 // Daniel Micay
 // Daniel Sabogal
 // Daurnimator
 // David Carlier
 // David Edelsohn
 // Denys Vlasenko
 // Dmitry Ivanov
 // Dmitry V. Levin
 // Drew DeVault
 // Emil Renner Berthing
 // Fangrui Song
 // Felix Fietkau
 // Felix Janda
 // Gianluca Anzolin
 // Hauke Mehrtens
 // He X
 // Hiltjo Posthuma
 // Isaac Dunham
 // Jaydeep Patil
 // Jens Gustedt
 // Jeremy Huntwork
 // Jo-Philipp Wich
 // Joakim Sindholt
 // John Spencer
 // Julien Ramseier
 // Justin Cormack
 // Kaarle Ritvanen
 // Khem Raj
 // Kylie McClain
 // Leah Neukirchen
 // Luca Barbato
 // Luka Perkov
 // M Farkas-Dyck (Strake)
 // Mahesh Bodapati
 // Markus Wichmann
 // Masanori Ogino
 // Michael Clark
 // Michael Forney
 // Mikhail Kremnyov
 // Natanael Copa
 // Nicholas J. Kain
 // orc
 // Pascal Cuoq
 // Patrick Oppenlander
 // Petr Hosek
 // Petr Skocik
 // Pierre Carrier
 // Reini Urban
 // Rich Felker
 // Richard Pennington
 // Ryan Fairfax
 // Samuel Holland
 // Segev Finer
 // Shiz
 // sin
 // Solar Designer
 // Stefan Kristiansson
 // Stefan O'Rear
 // Szabolcs Nagy
 // Timo Teräs
 // Trutz Behn
 // Valentin Ochs
 // Will Dietz
 // William Haddon
 // William Pitcock
 //
 // Portions of this software are derived from third-party works licensed
 // under terms compatible with the above MIT license:
 //
 // The TRE regular expression implementation (src/regex/reg* and
 // src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
 // under a 2-clause BSD license (license text in the source files). The
 // included version has been heavily modified by Rich Felker in 2012, in
 // the interests of size, simplicity, and namespace cleanliness.
 //
 // Much of the math library code (src/math/* and src/complex/*) is
 // Copyright © 1993,2004 Sun Microsystems or
 // Copyright © 2003-2011 David Schultz or
 // Copyright © 2003-2009 Steven G. Kargl or
 // Copyright © 2003-2009 Bruce D. Evans or
 // Copyright © 2008 Stephen L. Moshier or
 // Copyright © 2017-2018 Arm Limited
 // and labelled as such in comments in the individual source files. All
 // have been licensed under extremely permissive terms.
 //
 // The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008
 // The Android Open Source Project and is licensed under a two-clause BSD
 // license. It was taken from Bionic libc, used on Android.
 //
 // The AArch64 memcpy and memset code (src/string/aarch64/*) are
 // Copyright © 1999-2019, Arm Limited.
 //
 // The implementation of DES for crypt (src/crypt/crypt_des.c) is
 // Copyright © 1994 David Burren. It is licensed under a BSD license.
 //
 // The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
 // originally written by Solar Designer and placed into the public
 // domain. The code also comes with a fallback permissive license for use
 // in jurisdictions that may not recognize the public domain.
 //
 // The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
 // Valentin Ochs and is licensed under an MIT-style license.
 //
 // The x86_64 port was written by Nicholas J. Kain and is licensed under
 // the standard MIT terms.
 //
 // The mips and microblaze ports were originally written by Richard
 // Pennington for use in the ellcc project. The original code was adapted
 // by Rich Felker for build system and code conventions during upstream
 // integration. It is licensed under the standard MIT terms.
 //
 // The mips64 port was contributed by Imagination Technologies and is
 // licensed under the standard MIT terms.
 //
 // The powerpc port was also originally written by Richard Pennington,
 // and later supplemented and integrated by John Spencer. It is licensed
 // under the standard MIT terms.
 //
 // All other files which have no copyright comments are original works
 // produced specifically for use as part of this library, written either
 // by Rich Felker, the main author of the library, or by one or more
 // contibutors listed above. Details on authorship of individual files
 // can be found in the git version control history of the project. The
 // omission of copyright and license comments in each file is in the
 // interest of source tree size.
 //
 // In addition, permission is hereby granted for all public header files
 // (include/* and arch/*/bits/*) and crt files intended to be linked into
 // applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
 // the copyright notice and permission notice otherwise required by the
 // license, and to use these files without any requirement of
 // attribution. These files include substantial contributions from:
 //
 // Bobby Bingham
 // John Spencer
 // Nicholas J. Kain
 // Rich Felker
 // Richard Pennington
 // Stefan Kristiansson
 // Szabolcs Nagy
 //
 // all of whom have explicitly granted such permission.
 //
 // This file previously contained text expressing a belief that most of
 // the files covered by the above exception were sufficiently trivial not
 // to be subject to copyright, resulting in confusion over whether it
 // negated the permissions granted in the license. In the spirit of
 // permissive licensing, and of not having licensing issues being an
 // obstacle to adoption, that text has been removed.
 const ( /* copyright.c:194:1: */
 	__musl__copyright__ = 0
 )
 
 const ( /* pthread_impl.h:58:1: */
 	DT_EXITING  = 0
 	DT_JOINABLE = 1
 	DT_DETACHED = 2
 )
 
 type ptrdiff_t = int64 /* <builtin>:3:26 */
 
 type size_t = uint64 /* <builtin>:9:23 */
 
 type wchar_t = uint16 /* <builtin>:15:24 */
 
 type va_list = uintptr /* <builtin>:50:27 */
 
 type __locale_struct = struct{ cat [6]uintptr } /* alltypes.h:343:9 */
 
 type locale_t = uintptr /* alltypes.h:343:32 */
 
 func Xisalnum(tls *TLS, c int32) int32 { /* isalnum.c:3:5: */
 	return Bool32(func() int32 {
 		if 0 != 0 {
 			return Xisalpha(tls, c)
 		}
 		return Bool32(uint32(c)|uint32(32)-uint32('a') < uint32(26))
 	}() != 0 || func() int32 {
 		if 0 != 0 {
 			return Xisdigit(tls, c)
 		}
 		return Bool32(uint32(c)-uint32('0') < uint32(10))
 	}() != 0)
 }
 
 func X__isalnum_l(tls *TLS, c int32, l locale_t) int32 { /* isalnum.c:8:5: */
 	return Xisalnum(tls, c)
 }
 
 func Xisalpha(tls *TLS, c int32) int32 { /* isalpha.c:4:5: */
 	return Bool32(uint32(c)|uint32(32)-uint32('a') < uint32(26))
 }
 
 func X__isalpha_l(tls *TLS, c int32, l locale_t) int32 { /* isalpha.c:9:5: */
 	return Xisalpha(tls, c)
 }
 
 func Xisdigit(tls *TLS, c int32) int32 { /* isdigit.c:4:5: */
 	return Bool32(uint32(c)-uint32('0') < uint32(10))
 }
 
 func X__isdigit_l(tls *TLS, c int32, l locale_t) int32 { /* isdigit.c:9:5: */
 	return Xisdigit(tls, c)
 }
 
 func Xislower(tls *TLS, c int32) int32 { /* islower.c:4:5: */
 	return Bool32(uint32(c)-uint32('a') < uint32(26))
 }
 
 func X__islower_l(tls *TLS, c int32, l locale_t) int32 { /* islower.c:9:5: */
 	return Xislower(tls, c)
 }
 
 func Xisprint(tls *TLS, c int32) int32 { /* isprint.c:4:5: */
 	return Bool32(uint32(c)-uint32(0x20) < uint32(0x5f))
 }
 
 func X__isprint_l(tls *TLS, c int32, l locale_t) int32 { /* isprint.c:9:5: */
 	return Xisprint(tls, c)
 }
 
 func Xisspace(tls *TLS, c int32) int32 { /* isspace.c:4:5: */
 	return Bool32(c == ' ' || uint32(c)-uint32('\t') < uint32(5))
 }
 
 func X__isspace_l(tls *TLS, c int32, l locale_t) int32 { /* isspace.c:9:5: */
 	return Xisspace(tls, c)
 }
 
 func Xisxdigit(tls *TLS, c int32) int32 { /* isxdigit.c:3:5: */
 	return Bool32(func() int32 {
 		if 0 != 0 {
 			return Xisdigit(tls, c)
 		}
 		return Bool32(uint32(c)-uint32('0') < uint32(10))
 	}() != 0 || uint32(c)|uint32(32)-uint32('a') < uint32(6))
 }
 
 func X__isxdigit_l(tls *TLS, c int32, l locale_t) int32 { /* isxdigit.c:8:5: */
 	return Xisxdigit(tls, c)
 }
 
 type div_t = struct {
 	quot int32
 	rem  int32
 } /* stdlib.h:62:35 */
 type ldiv_t = struct {
 	quot int32
 	rem  int32
 } /* stdlib.h:63:36 */
 type lldiv_t = struct {
 	quot int64
 	rem  int64
 } /* stdlib.h:64:41 */
 
 type ssize_t = int32 /* alltypes.h:65:15 */
 
 type intptr_t = int32 /* alltypes.h:70:15 */
 
 type off_t = int32 /* alltypes.h:162:16 */
 
 type pid_t = int32 /* alltypes.h:235:13 */
 
 type uid_t = uint32 /* alltypes.h:245:18 */
 
 type gid_t = uint32 /* alltypes.h:250:18 */
 
 type useconds_t = uint32 /* alltypes.h:260:18 */
 
 func X__putenv(tls *TLS, s uintptr, l size_t, r uintptr) int32 { /* putenv.c:8:5: */
 	var i size_t
 	var newenv uintptr
 	var tmp uintptr
 	//TODO for (char **e = __environ; *e; e++, i++)
 	var e uintptr
 	i = uint64(0)
 	if !(Environ() != 0) {
 		goto __1
 	}
 	//TODO for (char **e = __environ; *e; e++, i++)
 	e = Environ()
 __2:
 	if !(*(*uintptr)(unsafe.Pointer(e)) != 0) {
 		goto __4
 	}
 	if !!(Xstrncmp(tls, s, *(*uintptr)(unsafe.Pointer(e)), l+uint64(1)) != 0) {
 		goto __5
 	}
 	tmp = *(*uintptr)(unsafe.Pointer(e))
 	*(*uintptr)(unsafe.Pointer(e)) = s
 	X__env_rm_add(tls, tmp, r)
 	return 0
 __5:
 	;
 	goto __3
 __3:
 	e += 8
 	i++
 	goto __2
 	goto __4
 __4:
 	;
 __1:
 	;
 	if !(Environ() == _soldenv) {
 		goto __6
 	}
 	newenv = Xrealloc(tls, _soldenv, uint64(unsafe.Sizeof(uintptr(0)))*(i+uint64(2)))
 	if !!(newenv != 0) {
 		goto __8
 	}
 	goto oom
 __8:
 	;
 	goto __7
 __6:
 	newenv = Xmalloc(tls, uint64(unsafe.Sizeof(uintptr(0)))*(i+uint64(2)))
 	if !!(newenv != 0) {
 		goto __9
 	}
 	goto oom
 __9:
 	;
 	if !(i != 0) {
 		goto __10
 	}
 	Xmemcpy(tls, newenv, Environ(), uint64(unsafe.Sizeof(uintptr(0)))*i)
 __10:
 	;
 	Xfree(tls, _soldenv)
 __7:
 	;
 	*(*uintptr)(unsafe.Pointer(newenv + uintptr(i)*8)) = s
 	*(*uintptr)(unsafe.Pointer(newenv + uintptr(i+uint64(1))*8)) = uintptr(0)
 	*(*uintptr)(unsafe.Pointer(EnvironP())) = AssignPtrUintptr(uintptr(unsafe.Pointer(&_soldenv)), newenv)
 	if !(r != 0) {
 		goto __11
 	}
 	X__env_rm_add(tls, uintptr(0), r)
 __11:
 	;
 	return 0
 oom:
 	Xfree(tls, r)
 	return -1
 }
 
 var _soldenv uintptr /* putenv.c:22:14: */
 
 func Xputenv(tls *TLS, s uintptr) int32 { /* putenv.c:43:5: */
 	var l size_t = size_t((int64(X__strchrnul(tls, s, '=')) - int64(s)) / 1)
 	if !(l != 0) || !(int32(*(*int8)(unsafe.Pointer(s + uintptr(l)))) != 0) {
 		return Xunsetenv(tls, s)
 	}
 	return X__putenv(tls, s, l, uintptr(0))
 }
 
 func X__env_rm_add(tls *TLS, old uintptr, new uintptr) { /* setenv.c:5:6: */
 	//TODO for (size_t i=0; i < env_alloced_n; i++)
 	var i size_t = uint64(0)
 	for ; i < _senv_alloced_n; i++ {
 		if *(*uintptr)(unsafe.Pointer(_senv_alloced + uintptr(i)*8)) == old {
 			*(*uintptr)(unsafe.Pointer(_senv_alloced + uintptr(i)*8)) = new
 			Xfree(tls, old)
 			return
 		} else if !(int32(*(*uintptr)(unsafe.Pointer(_senv_alloced + uintptr(i)*8))) != 0) && new != 0 {
 			*(*uintptr)(unsafe.Pointer(_senv_alloced + uintptr(i)*8)) = new
 			new = uintptr(0)
 		}
 	}
 	if !(new != 0) {
 		return
 	}
 	var t uintptr = Xrealloc(tls, _senv_alloced, uint64(unsafe.Sizeof(uintptr(0)))*(_senv_alloced_n+uint64(1)))
 	if !(t != 0) {
 		return
 	}
 	*(*uintptr)(unsafe.Pointer(AssignPtrUintptr(uintptr(unsafe.Pointer(&_senv_alloced)), t) + uintptr(PostIncUint64(&_senv_alloced_n, 1))*8)) = new
 }
 
 var _senv_alloced uintptr  /* setenv.c:7:14: */
 var _senv_alloced_n size_t /* setenv.c:8:16: */
 
 func Xsetenv(tls *TLS, var1 uintptr, value uintptr, overwrite int32) int32 { /* setenv.c:26:5: */
 	var s uintptr
 	var l1 size_t
 	var l2 size_t
 
 	if !(var1 != 0) || !(int32(AssignUint64(&l1, size_t((int64(X__strchrnul(tls, var1, '='))-int64(var1))/1))) != 0) || *(*int8)(unsafe.Pointer(var1 + uintptr(l1))) != 0 {
 		*(*int32)(unsafe.Pointer(X___errno_location(tls))) = 22
 		return -1
 	}
 	if !(overwrite != 0) && Xgetenv(tls, var1) != 0 {
 		return 0
 	}
 
 	l2 = Xstrlen(tls, value)
 	s = Xmalloc(tls, l1+l2+uint64(2))
 	if !(s != 0) {
 		return -1
 	}
 	Xmemcpy(tls, s, var1, l1)
 	*(*int8)(unsafe.Pointer(s + uintptr(l1))) = int8('=')
 	Xmemcpy(tls, s+uintptr(l1)+uintptr(1), value, l2+uint64(1))
 	return X__putenv(tls, s, l1, s)
 }
 
 func Xunsetenv(tls *TLS, name uintptr) int32 { /* unsetenv.c:9:5: */
 	var l size_t = size_t((int64(X__strchrnul(tls, name, '=')) - int64(name)) / 1)
 	if !(l != 0) || *(*int8)(unsafe.Pointer(name + uintptr(l))) != 0 {
 		*(*int32)(unsafe.Pointer(X___errno_location(tls))) = 22
 		return -1
 	}
 	if Environ() != 0 {
 		var e uintptr = Environ()
 		var eo uintptr = e
 		for ; *(*uintptr)(unsafe.Pointer(e)) != 0; e += 8 {
 			//TODO if (!strncmp(name, *e, l) && l[*e] == '=')
 			if !(Xstrncmp(tls, name, *(*uintptr)(unsafe.Pointer(e)), l) != 0) && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(e)) + uintptr(l)))) == '=' {
 				X__env_rm_add(tls, *(*uintptr)(unsafe.Pointer(e)), uintptr(0))
 			} else if eo != e {
 				*(*uintptr)(unsafe.Pointer(PostIncUintptr(&eo, 8))) = *(*uintptr)(unsafe.Pointer(e))
 			} else {
 				eo += 8
 			}
 		}
 		if eo != e {
 			*(*uintptr)(unsafe.Pointer(eo)) = uintptr(0)
 		}
 	}
 	return 0
 }
 
 type wint_t = uint32 /* alltypes.h:198:18 */
 
 type wctype_t = uint32 /* alltypes.h:203:23 */
 
 type __mbstate_t = struct {
 	__opaque1 uint32
 	__opaque2 uint32
 } /* alltypes.h:337:9 */
 
 type mbstate_t = __mbstate_t /* alltypes.h:337:63 */
 
 type tm = struct {
 	tm_sec    int32
 	tm_min    int32
 	tm_hour   int32
 	tm_mday   int32
 	tm_mon    int32
 	tm_year   int32
 	tm_wday   int32
 	tm_yday   int32
 	tm_isdst  int32
 	tm_gmtoff int32
 	tm_zone   uintptr
 } /* wchar.h:138:1 */
 
 type uintptr_t = uint32 /* alltypes.h:55:24 */
 
 type int8_t = int8 /* alltypes.h:96:25 */
 
 type int16_t = int16 /* alltypes.h:101:25 */
 
 type int32_t = int32 /* alltypes.h:106:25 */
 
 type int64_t = int32 /* alltypes.h:111:25 */
 
 type intmax_t = int32 /* alltypes.h:116:25 */
 
 type uint8_t = uint8 /* alltypes.h:121:25 */
 
 type uint16_t = uint16 /* alltypes.h:126:25 */
 
 type uint32_t = uint32 /* alltypes.h:131:25 */
 
 type uint64_t = uint32 /* alltypes.h:136:25 */
 
 type uintmax_t = uint32 /* alltypes.h:146:25 */
 
 type int_fast8_t = int8_t   /* stdint.h:22:16 */
 type int_fast64_t = int64_t /* stdint.h:23:17 */
 
 type int_least8_t = int8_t   /* stdint.h:25:17 */
 type int_least16_t = int16_t /* stdint.h:26:17 */
 type int_least32_t = int32_t /* stdint.h:27:17 */
 type int_least64_t = int64_t /* stdint.h:28:17 */
 
 type uint_fast8_t = uint8_t   /* stdint.h:30:17 */
 type uint_fast64_t = uint64_t /* stdint.h:31:18 */
 
 type uint_least8_t = uint8_t   /* stdint.h:33:18 */
 type uint_least16_t = uint16_t /* stdint.h:34:18 */
 type uint_least32_t = uint32_t /* stdint.h:35:18 */
 type uint_least64_t = uint64_t /* stdint.h:36:18 */
 
 type int_fast16_t = int32_t   /* stdint.h:1:17 */
 type int_fast32_t = int32_t   /* stdint.h:2:17 */
 type uint_fast16_t = uint32_t /* stdint.h:3:18 */
 type uint_fast32_t = uint32_t /* stdint.h:4:18 */
 
 // Upper 6 state bits are a negative integer offset to bound-check next byte
 //    equivalent to: ( (b-0x80) | (b+offset) ) & ~0x3f
 
 // Interval [a,b). Either a must be 80 or b must be c0, lower 3 bits clear.
 
 // Arbitrary encoding for representing code units instead of characters.
 
 // Get inline definition of MB_CUR_MAX.
 
 type lconv = struct {
 	decimal_point      uintptr
 	thousands_sep      uintptr
 	grouping           uintptr
 	int_curr_symbol    uintptr
 	currency_symbol    uintptr
 	mon_decimal_point  uintptr
 	mon_thousands_sep  uintptr
 	mon_grouping       uintptr
 	positive_sign      uintptr
 	negative_sign      uintptr
 	int_frac_digits    int8
 	frac_digits        int8
 	p_cs_precedes      int8
 	p_sep_by_space     int8
 	n_cs_precedes      int8
 	n_sep_by_space     int8
 	p_sign_posn        int8
 	n_sign_posn        int8
 	int_p_cs_precedes  int8
 	int_p_sep_by_space int8
 	int_n_cs_precedes  int8
 	int_n_sep_by_space int8
 	int_p_sign_posn    int8
 	int_n_sign_posn    int8
 	_                  [2]byte
 } /* locale.h:24:1 */
 
 type _G_fpos64_t = struct {
 	_        [0]uint64
 	__opaque [16]int8
 } /* stdio.h:54:9 */
 
 type fpos_t = _G_fpos64_t /* stdio.h:58:3 */
 
 // Support signed or unsigned plain-char
 
 // Implementation choices...
 
 // Arbitrary numbers...
 
 // POSIX/SUS requirements follow. These numbers come directly
 // from SUS and have nothing to do with the host system.
 
 type __locale_map = struct {
 	__map    uintptr
 	map_size size_t
 	name     [24]int8
 	next     uintptr
 } /* alltypes.h:343:9 */
 
 type tls_module = struct {
 	next   uintptr
 	image  uintptr
 	len    size_t
 	size   size_t
 	align  size_t
 	offset size_t
 } /* libc.h:14:1 */
 
 type __libc = struct {
 	can_do_threads  int8
 	threaded        int8
 	secure          int8
 	need_locks      int8
 	threads_minus_1 int32
 	auxv            uintptr
 	tls_head        uintptr
 	tls_size        size_t
 	tls_align       size_t
 	tls_cnt         size_t
 	page_size       size_t
 	global_locale   struct{ cat [6]uintptr }
 } /* libc.h:20:1 */
 
 type time_t = int32 /* alltypes.h:85:16 */
 
 type clockid_t = int32 /* alltypes.h:214:13 */
 
 type timespec = struct {
 	tv_sec  time_t
 	tv_nsec int32
 } /* alltypes.h:229:1 */
 
 type __pthread = struct {
 	self          uintptr
 	dtv           uintptr
 	prev          uintptr
 	next          uintptr
 	sysinfo       uintptr_t
 	canary        uintptr_t
 	canary2       uintptr_t
 	tid           int32
 	errno_val     int32
 	detach_state  int32
 	cancel        int32
 	canceldisable uint8
 	cancelasync   uint8
 	tsd_used      uint8 /* unsigned char tsd_used: 1, unsigned char dlerror_flag: 1 */
 	_             [1]byte
 	map_base      uintptr
 	map_size      size_t
 	stack         uintptr
 	stack_size    size_t
 	guard_size    size_t
 	result        uintptr
 	cancelbuf     uintptr
 	tsd           uintptr
 	robust_list   struct {
 		head    uintptr
 		off     int32
 		_       [4]byte
 		pending uintptr
 	}
 	timer_id      int32
 	_             [4]byte
 	locale        locale_t
 	killlock      [1]int32
 	_             [4]byte
 	dlerror_buf   uintptr
 	stdio_locks   uintptr
 	canary_at_end uintptr_t
 	_             [4]byte
 	dtv_copy      uintptr
 } /* alltypes.h:273:9 */
 
 type pthread_t = uintptr /* alltypes.h:273:26 */
 
 type pthread_once_t = int32 /* alltypes.h:279:13 */
 
 type pthread_key_t = uint32 /* alltypes.h:284:18 */
 
 type pthread_spinlock_t = int32 /* alltypes.h:289:13 */
 
 type pthread_mutexattr_t = struct{ __attr uint32 } /* alltypes.h:294:37 */
 
 type pthread_condattr_t = struct{ __attr uint32 } /* alltypes.h:299:37 */
 
 type pthread_barrierattr_t = struct{ __attr uint32 } /* alltypes.h:304:37 */
 
 type pthread_rwlockattr_t = struct{ __attr [2]uint32 } /* alltypes.h:309:40 */
 
 type __sigset_t = struct{ __bits [32]uint32 } /* alltypes.h:349:9 */
 
 type sigset_t = __sigset_t /* alltypes.h:349:71 */
 
 type pthread_attr_t = struct{ __u struct{ __i [9]int32 } } /* alltypes.h:372:147 */
 
 type pthread_mutex_t = struct {
 	__u struct {
 		_   [0]uint64
 		__i [6]int32
 		_   [24]byte
 	}
 } /* alltypes.h:377:157 */
 
 type pthread_cond_t = struct {
 	__u struct {
 		_   [0]uint64
 		__i [12]int32
 	}
 } /* alltypes.h:387:112 */
 
 type pthread_rwlock_t = struct {
 	__u struct {
 		_   [0]uint64
 		__i [8]int32
 		_   [32]byte
 	}
 } /* alltypes.h:397:139 */
 
 type pthread_barrier_t = struct {
 	__u struct {
 		_   [0]uint64
 		__i [5]int32
 		_   [20]byte
 	}
 } /* alltypes.h:402:137 */
 
 type sched_param = struct {
 	sched_priority int32
 	__reserved1    int32
 	__reserved2    [2]struct {
 		__reserved1 time_t
 		__reserved2 int32
 	}
 	__reserved3 int32
 } /* sched.h:19:1 */
 
 type timer_t = uintptr /* alltypes.h:209:14 */
 
 type clock_t = int32 /* alltypes.h:219:14 */
 
 type itimerspec = struct {
 	it_interval struct {
 		tv_sec  time_t
 		tv_nsec int32
 	}
 	it_value struct {
 		tv_sec  time_t
 		tv_nsec int32
 	}
 } /* time.h:80:1 */
 
 type sigevent = struct {
 	sigev_value struct {
 		_         [0]uint64
 		sival_int int32
 		_         [4]byte
 	}
 	sigev_signo             int32
 	sigev_notify            int32
 	sigev_notify_function   uintptr
 	sigev_notify_attributes uintptr
 	__pad                   [44]int8
 	_                       [4]byte
 } /* time.h:107:1 */
 
 type __ptcb = struct {
 	__f    uintptr
 	__x    uintptr
 	__next uintptr
 } /* alltypes.h:273:9 */
 
 type sigaltstack = struct {
 	ss_sp    uintptr
 	ss_flags int32
 	_        [4]byte
 	ss_size  size_t
 } /* signal.h:44:9 */
 
 type stack_t = sigaltstack /* signal.h:44:28 */
 
 type greg_t = int64        /* signal.h:59:19 */
 type gregset_t = [23]int64 /* signal.h:59:27 */
 type _fpstate = struct {
 	cwd       uint16
 	swd       uint16
 	ftw       uint16
 	fop       uint16
 	rip       uint64
 	rdp       uint64
 	mxcsr     uint32
 	mxcr_mask uint32
 	_st       [8]struct {
 		significand [4]uint16
 		exponent    uint16
 		padding     [3]uint16
 	}
 	_xmm    [16]struct{ element [4]uint32 }
 	padding [24]uint32
 } /* signal.h:60:9 */
 
 type fpregset_t = uintptr /* signal.h:71:3 */
 type sigcontext = struct {
 	r8          uint32
 	r9          uint32
 	r10         uint32
 	r11         uint32
 	r12         uint32
 	r13         uint32
 	r14         uint32
 	r15         uint32
 	rdi         uint32
 	rsi         uint32
 	rbp         uint32
 	rbx         uint32
 	rdx         uint32
 	rax         uint32
 	rcx         uint32
 	rsp         uint32
 	rip         uint32
 	eflags      uint32
 	cs          uint16
 	gs          uint16
 	fs          uint16
 	__pad0      uint16
 	err         uint32
 	trapno      uint32
 	oldmask     uint32
 	cr2         uint32
 	fpstate     uintptr
 	__reserved1 [8]uint32
 } /* signal.h:72:1 */
 
 type mcontext_t = struct {
 	gregs       gregset_t
 	fpregs      fpregset_t
 	__reserved1 [8]uint64
 } /* signal.h:84:3 */
 
 type __ucontext = struct {
 	uc_flags     uint32
 	_            [4]byte
 	uc_link      uintptr
 	uc_stack     stack_t
 	uc_mcontext  mcontext_t
 	uc_sigmask   sigset_t
 	__fpregs_mem [64]uint32
 } /* signal.h:97:9 */
 
 type ucontext_t = __ucontext /* signal.h:104:3 */
 
 type sigval = struct {
 	_         [0]uint64
 	sival_int int32
 	_         [4]byte
 } /* time.h:107:1 */
 
 type siginfo_t = struct {
 	si_signo    int32
 	si_errno    int32
 	si_code     int32
 	_           [4]byte
 	__si_fields struct {
 		_     [0]uint64
 		__pad [116]int8
 		_     [4]byte
 	}
 } /* signal.h:145:3 */
 
 type sigaction = struct {
 	__sa_handler struct{ sa_handler uintptr }
 	sa_mask      sigset_t
 	sa_flags     int32
 	_            [4]byte
 	sa_restorer  uintptr
 } /* signal.h:167:1 */
 
 type sig_t = uintptr /* signal.h:251:14 */
 
 type sig_atomic_t = int32 /* signal.h:269:13 */
 
 type mode_t = uint32 /* alltypes.h:152:18 */
 
 type syscall_arg_t = int32 /* syscall.h:22:14 */
 
 func a_cas(tls *TLS, p uintptr, t int32, s int32) int32 { /* atomic_arch.h:2:19: */
 	panic(`arch\x86_64\atomic_arch.h:4:2: assembler statements not supported`)
 	return t
 }
 
 func a_or(tls *TLS, p uintptr, v int32) { /* atomic_arch.h:46:20: */
 	panic(`arch\x86_64\atomic_arch.h:48:2: assembler statements not supported`)
 }
 
 func a_or_64(tls *TLS, p uintptr, v uint64_t) { /* atomic_arch.h:62:20: */
 	panic(`arch\x86_64\atomic_arch.h:64:2: assembler statements not supported`)
 }
 
 func a_ctz_64(tls *TLS, x uint64_t) int32 { /* atomic_arch.h:112:19: */
 	panic(`arch\x86_64\atomic_arch.h:114:2: assembler statements not supported`)
 	return int32(x)
 }
 
 func a_ctz_32(tls *TLS, x uint32_t) int32 { /* atomic.h:256:19: */
 	return int32(_sdebruijn32[x&-x*uint32_t(0x076be629)>>27])
 }
 
 var _sdebruijn32 = [32]int8{
 	int8(0), int8(1), int8(23), int8(2), int8(29), int8(24), int8(19), int8(3), int8(30), int8(27), int8(25), int8(11), int8(20), int8(8), int8(4), int8(13),
 	int8(31), int8(22), int8(28), int8(18), int8(26), int8(10), int8(7), int8(12), int8(21), int8(17), int8(9), int8(6), int8(16), int8(5), int8(15), int8(14),
 } /* atomic.h:261:20 */
 
 type __timer = struct {
 	timerid int32
 	_       [4]byte
 	thread  pthread_t
 } /* pthread_impl.h:64:1 */
 
 func __pthread_self(tls *TLS) uintptr { /* pthread_arch.h:1:30: */
 	var self uintptr
 	panic(`arch\x86_64\pthread_arch.h:4:2: assembler statements not supported`)
 	return self
 }
 
 func Xwcrtomb(tls *TLS, s uintptr, wc wchar_t, st uintptr) size_t { /* wcrtomb.c:6:8: */
 	if !(s != 0) {
 		return uint64(1)
 	}
 	if uint32(wc) < uint32(0x80) {
 		*(*int8)(unsafe.Pointer(s)) = int8(wc)
 		return uint64(1)
 	} else if func() int32 {
 		if !!(int32(*(*uintptr)(unsafe.Pointer((*__pthread)(unsafe.Pointer(__pthread_self(tls))).locale))) != 0) {
 			return 4
 		}
 		return 1
 	}() == 1 {
 		if !(uint32(wc)-uint32(0xdf80) < uint32(0x80)) {
 			*(*int32)(unsafe.Pointer(X___errno_location(tls))) = 84
 			return Uint64FromInt32(-1)
 		}
 		*(*int8)(unsafe.Pointer(s)) = int8(wc)
 		return uint64(1)
 	} else if uint32(wc) < uint32(0x800) {
 		*(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1))) = int8(0xc0 | int32(wc)>>6)
 		*(*int8)(unsafe.Pointer(s)) = int8(0x80 | int32(wc)&0x3f)
 		return uint64(2)
 	} else if uint32(wc) < uint32(0xd800) || uint32(wc)-uint32(0xe000) < uint32(0x2000) {
 		*(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1))) = int8(0xe0 | int32(wc)>>12)
 		*(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1))) = int8(0x80 | int32(wc)>>6&0x3f)
 		*(*int8)(unsafe.Pointer(s)) = int8(0x80 | int32(wc)&0x3f)
 		return uint64(3)
 	} else if uint32(wc)-uint32(0x10000) < uint32(0x100000) {
 		*(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1))) = int8(0xf0 | int32(wc)>>18)
 		*(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1))) = int8(0x80 | int32(wc)>>12&0x3f)
 		*(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1))) = int8(0x80 | int32(wc)>>6&0x3f)
 		*(*int8)(unsafe.Pointer(s)) = int8(0x80 | int32(wc)&0x3f)
 		return uint64(4)
 	}
 	*(*int32)(unsafe.Pointer(X___errno_location(tls))) = 84
 	return Uint64FromInt32(-1)
 }
 
 func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n size_t, st uintptr) size_t { /* wcsrtombs.c:3:8: */
 	bp := tls.Alloc(4)
 	defer tls.Free(4)
 
 	var ws2 uintptr
 	// var buf [4]int8 at bp, 4
 
 	var N size_t = n
 	var l size_t
 	if !(s != 0) {
 		n = uint64(0)
 		ws2 = *(*uintptr)(unsafe.Pointer(ws))
 		for ; *(*wchar_t)(unsafe.Pointer(ws2)) != 0; ws2 += 2 {
 			if uint32(*(*wchar_t)(unsafe.Pointer(ws2))) >= 0x80 {
 				l = Xwcrtomb(tls, bp, *(*wchar_t)(unsafe.Pointer(ws2)), uintptr(0))
 				if !(l+uint64(1) != 0) {
 					return Uint64FromInt32(-1)
 				}
 				n = n + l
 			} else {
 				n++
 			}
 		}
 		return n
 	}
 	for n >= uint64(4) {
 		if uint32(*(*wchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))))-1 >= 0x7f {
 			if !(int32(*(*wchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) != 0) {
 				*(*int8)(unsafe.Pointer(s)) = int8(0)
 				*(*uintptr)(unsafe.Pointer(ws)) = uintptr(0)
 				return N - n
 			}
 			l = Xwcrtomb(tls, s, *(*wchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0))
 			if !(l+uint64(1) != 0) {
 				return Uint64FromInt32(-1)
 			}
 			s += uintptr(l)
 			n = n - l
 		} else {
 			*(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1))) = int8(*(*wchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))))
 			n--
 		}
 		*(*uintptr)(unsafe.Pointer(ws)) += 2
 	}
 	for n != 0 {
 		if uint32(*(*wchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))))-1 >= 0x7f {
 			if !(int32(*(*wchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) != 0) {
 				*(*int8)(unsafe.Pointer(s)) = int8(0)
 				*(*uintptr)(unsafe.Pointer(ws)) = uintptr(0)
 				return N - n
 			}
 			l = Xwcrtomb(tls, bp, *(*wchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0))
 			if !(l+uint64(1) != 0) {
 				return Uint64FromInt32(-1)
 			}
 			if l > n {
 				return N - n
 			}
 			Xwcrtomb(tls, s, *(*wchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0))
 			s += uintptr(l)
 			n = n - l
 		} else {
 			*(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1))) = int8(*(*wchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))))
 			n--
 		}
 		*(*uintptr)(unsafe.Pointer(ws)) += 2
 	}
 	return N
 }
 
 func Xwcstombs(tls *TLS, s uintptr, ws uintptr, n size_t) size_t { /* wcstombs.c:4:8: */
 	bp := tls.Alloc(8)
 	defer tls.Free(8)
 	*(*uintptr)(unsafe.Pointer(bp)) = ws
 
 	//TODO return wcsrtombs(s, &(const wchar_t *){ws}, n, 0);
 	return Xwcsrtombs(tls, s, bp, n, uintptr(0))
 }
 
 func Xbsearch(tls *TLS, key uintptr, base uintptr, nel size_t, width size_t, cmp uintptr) uintptr { /* bsearch.c:3:6: */
 	var try uintptr
 	var sign int32
 	for nel > uint64(0) {
 		try = base + uintptr(width*(nel/uint64(2)))
 		sign = (*struct {
 			f func(*TLS, uintptr, uintptr) int32
 		})(unsafe.Pointer(&struct{ uintptr }{cmp})).f(tls, key, try)
 		if sign < 0 {
 			nel = nel / uint64(2)
 		} else if sign > 0 {
 			base = try + uintptr(width)
 			nel = nel - (nel/uint64(2) + uint64(1))
 		} else {
 			return try
 		}
 	}
 	return uintptr(0)
 }
 
 // Support signed or unsigned plain-char
 
 // Implementation choices...
 
 // Arbitrary numbers...
 
 // POSIX/SUS requirements follow. These numbers come directly
 // from SUS and have nothing to do with the host system.
 
 func X__strchrnul(tls *TLS, s uintptr, c int32) uintptr { /* strchrnul.c:10:6: */
 	c = int32(uint8(c))
 	if !(c != 0) {
 		return s + uintptr(Xstrlen(tls, s))
 	}
 	var w uintptr
 	for ; uint64(s)%uint64(unsafe.Sizeof(size_t(0))) != 0; s++ {
 		if !(int32(*(*int8)(unsafe.Pointer(s))) != 0) || int32(*(*uint8)(unsafe.Pointer(s))) == c {
 			return s
 		}
 	}
 	var k size_t = Uint64(Uint64FromInt32(-1)) / uint64(255) * size_t(c)
 	for w = s; !((*(*uint64)(unsafe.Pointer(w))-Uint64(Uint64FromInt32(-1))/uint64(255)) & ^*(*uint64)(unsafe.Pointer(w)) & (Uint64(Uint64FromInt32(-1))/uint64(255)*uint64(255/2+1)) != 0) && !((*(*uint64)(unsafe.Pointer(w))^k-Uint64(Uint64FromInt32(-1))/uint64(255)) & ^(*(*uint64)(unsafe.Pointer(w))^k) & (Uint64(Uint64FromInt32(-1))/uint64(255)*uint64(255/2+1)) != 0); w += 8 {
 	}
 	s = w
 	for ; *(*int8)(unsafe.Pointer(s)) != 0 && int32(*(*uint8)(unsafe.Pointer(s))) != c; s++ {
 	}
 	return s
 }
 
 func Xstrdup(tls *TLS, s uintptr) uintptr { /* strdup.c:4:6: */
 	var l size_t = Xstrlen(tls, s)
 	var d uintptr = Xmalloc(tls, l+uint64(1))
 	if !(d != 0) {
 		return uintptr(0)
 	}
 	return Xmemcpy(tls, d, s, l+uint64(1))
 }