gtsocial-umbx

musl_windows_386.go (30972B)

---

 // Code generated by 'ccgo -D__environ=environ -export-externs X -hide __syscall0,__syscall1,__syscall2,__syscall3,__syscall4,__syscall5,__syscall6 -nostdinc -nostdlib -o ../musl_windows_386.go -pkgname libc -static-locals-prefix _s -Iarch/i386 -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/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 = int32 /* <builtin>:3:26 */
 
 type size_t = uint32 /* <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:366:9 */
 
 type locale_t = uintptr /* alltypes.h:366: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:88:15 */
 
 type intptr_t = int32 /* alltypes.h:93:15 */
 
 type off_t = int64 /* alltypes.h:185:16 */
 
 type pid_t = int32 /* alltypes.h:258:13 */
 
 type uid_t = uint32 /* alltypes.h:268:18 */
 
 type gid_t = uint32 /* alltypes.h:273:18 */
 
 type useconds_t = uint32 /* alltypes.h:283: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 = size_t(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+size_t(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 += 4
 	i++
 	goto __2
 	goto __4
 __4:
 	;
 __1:
 	;
 	if !(Environ() == _soldenv) {
 		goto __6
 	}
 	newenv = Xrealloc(tls, _soldenv, uint32(unsafe.Sizeof(uintptr(0)))*(i+size_t(2)))
 	if !!(newenv != 0) {
 		goto __8
 	}
 	goto oom
 __8:
 	;
 	goto __7
 __6:
 	newenv = Xmalloc(tls, uint32(unsafe.Sizeof(uintptr(0)))*(i+size_t(2)))
 	if !!(newenv != 0) {
 		goto __9
 	}
 	goto oom
 __9:
 	;
 	if !(i != 0) {
 		goto __10
 	}
 	Xmemcpy(tls, newenv, Environ(), uint32(unsafe.Sizeof(uintptr(0)))*i)
 __10:
 	;
 	Xfree(tls, _soldenv)
 __7:
 	;
 	*(*uintptr)(unsafe.Pointer(newenv + uintptr(i)*4)) = s
 	*(*uintptr)(unsafe.Pointer(newenv + uintptr(i+size_t(1))*4)) = 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((int32(X__strchrnul(tls, s, '=')) - int32(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 = size_t(0)
 	for ; i < _senv_alloced_n; i++ {
 		if *(*uintptr)(unsafe.Pointer(_senv_alloced + uintptr(i)*4)) == old {
 			*(*uintptr)(unsafe.Pointer(_senv_alloced + uintptr(i)*4)) = new
 			Xfree(tls, old)
 			return
 		} else if !(int32(*(*uintptr)(unsafe.Pointer(_senv_alloced + uintptr(i)*4))) != 0) && new != 0 {
 			*(*uintptr)(unsafe.Pointer(_senv_alloced + uintptr(i)*4)) = new
 			new = uintptr(0)
 		}
 	}
 	if !(new != 0) {
 		return
 	}
 	var t uintptr = Xrealloc(tls, _senv_alloced, uint32(unsafe.Sizeof(uintptr(0)))*(_senv_alloced_n+size_t(1)))
 	if !(t != 0) {
 		return
 	}
 	*(*uintptr)(unsafe.Pointer(AssignPtrUintptr(uintptr(unsafe.Pointer(&_senv_alloced)), t) + uintptr(PostIncUint32(&_senv_alloced_n, 1))*4)) = 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(AssignUint32(&l1, size_t((int32(X__strchrnul(tls, var1, '='))-int32(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+size_t(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+size_t(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((int32(X__strchrnul(tls, name, '=')) - int32(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 += 4 {
 			//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, 4))) = *(*uintptr)(unsafe.Pointer(e))
 			} else {
 				eo += 4
 			}
 		}
 		if eo != e {
 			*(*uintptr)(unsafe.Pointer(eo)) = uintptr(0)
 		}
 	}
 	return 0
 }
 
 type wint_t = uint32 /* alltypes.h:221:18 */
 
 type wctype_t = uint32 /* alltypes.h:226:23 */
 
 type __mbstate_t = struct {
 	__opaque1 uint32
 	__opaque2 uint32
 } /* alltypes.h:360:9 */
 
 type mbstate_t = __mbstate_t /* alltypes.h:360: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:78:24 */
 
 type int8_t = int8 /* alltypes.h:119:25 */
 
 type int16_t = int16 /* alltypes.h:124:25 */
 
 type int32_t = int32 /* alltypes.h:129:25 */
 
 type int64_t = int64 /* alltypes.h:134:25 */
 
 type intmax_t = int64 /* alltypes.h:139:25 */
 
 type uint8_t = uint8 /* alltypes.h:144:25 */
 
 type uint16_t = uint16 /* alltypes.h:149:25 */
 
 type uint32_t = uint32 /* alltypes.h:154:25 */
 
 type uint64_t = uint64 /* alltypes.h:159:25 */
 
 type uintmax_t = uint64 /* alltypes.h:169: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:366: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 = int64 /* alltypes.h:108:16 */
 
 type clockid_t = int32 /* alltypes.h:237:13 */
 
 type timespec = struct {
 	tv_sec  time_t
 	tv_nsec int32
 	__12    uint32 /* int : 32 */
 } /* alltypes.h:252: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
 		pending uintptr
 	}
 	timer_id      int32
 	locale        locale_t
 	killlock      [1]int32
 	dlerror_buf   uintptr
 	stdio_locks   uintptr
 	canary_at_end uintptr_t
 	dtv_copy      uintptr
 } /* alltypes.h:296:9 */
 
 type pthread_t = uintptr /* alltypes.h:296:26 */
 
 type pthread_once_t = int32 /* alltypes.h:302:13 */
 
 type pthread_key_t = uint32 /* alltypes.h:307:18 */
 
 type pthread_spinlock_t = int32 /* alltypes.h:312:13 */
 
 type pthread_mutexattr_t = struct{ __attr uint32 } /* alltypes.h:317:37 */
 
 type pthread_condattr_t = struct{ __attr uint32 } /* alltypes.h:322:37 */
 
 type pthread_barrierattr_t = struct{ __attr uint32 } /* alltypes.h:327:37 */
 
 type pthread_rwlockattr_t = struct{ __attr [2]uint32 } /* alltypes.h:332:40 */
 
 type __sigset_t = struct{ __bits [32]uint32 } /* alltypes.h:372:9 */
 
 type sigset_t = __sigset_t /* alltypes.h:372:71 */
 
 type pthread_attr_t = struct{ __u struct{ __i [9]int32 } } /* alltypes.h:395:147 */
 
 type pthread_mutex_t = struct{ __u struct{ __i [6]int32 } } /* alltypes.h:400:157 */
 
 type pthread_cond_t = struct{ __u struct{ __i [12]int32 } } /* alltypes.h:410:112 */
 
 type pthread_rwlock_t = struct{ __u struct{ __i [8]int32 } } /* alltypes.h:420:139 */
 
 type pthread_barrier_t = struct{ __u struct{ __i [5]int32 } } /* alltypes.h:425:137 */
 
 type sched_param = struct {
 	sched_priority int32
 	__reserved1    int32
 	__reserved2    [4]int32
 	__reserved3    int32
 } /* sched.h:19:1 */
 
 type timer_t = uintptr /* alltypes.h:232:14 */
 
 type clock_t = int32 /* alltypes.h:242:14 */
 
 type itimerspec = struct {
 	it_interval struct {
 		tv_sec  time_t
 		tv_nsec int32
 		__12    uint32 /* int : 32 */
 	}
 	it_value struct {
 		tv_sec  time_t
 		tv_nsec int32
 		__12    uint32 /* int : 32 */
 	}
 } /* time.h:80:1 */
 
 type sigevent = struct {
 	sigev_value             struct{ sival_int int32 }
 	sigev_signo             int32
 	sigev_notify            int32
 	sigev_notify_function   uintptr
 	sigev_notify_attributes uintptr
 	__pad                   [44]int8
 } /* time.h:107:1 */
 
 type __ptcb = struct {
 	__f    uintptr
 	__x    uintptr
 	__next uintptr
 } /* alltypes.h:296:9 */
 
 type sigaltstack = struct {
 	ss_sp    uintptr
 	ss_flags int32
 	ss_size  size_t
 } /* signal.h:44:9 */
 
 type stack_t = sigaltstack /* signal.h:44:28 */
 
 type greg_t = int32        /* signal.h:51:13 */
 type gregset_t = [19]int32 /* signal.h:51:21 */
 type _fpstate = struct {
 	cw      uint32
 	sw      uint32
 	tag     uint32
 	ipoff   uint32
 	cssel   uint32
 	dataoff uint32
 	datasel uint32
 	_st     [8]struct {
 		significand [4]uint16
 		exponent    uint16
 	}
 	status uint32
 } /* signal.h:52:9 */
 
 type fpregset_t = uintptr /* signal.h:58:3 */
 type sigcontext = struct {
 	gs            uint16
 	__gsh         uint16
 	fs            uint16
 	__fsh         uint16
 	es            uint16
 	__esh         uint16
 	ds            uint16
 	__dsh         uint16
 	edi           uint32
 	esi           uint32
 	ebp           uint32
 	esp           uint32
 	ebx           uint32
 	edx           uint32
 	ecx           uint32
 	eax           uint32
 	trapno        uint32
 	err           uint32
 	eip           uint32
 	cs            uint16
 	__csh         uint16
 	eflags        uint32
 	esp_at_signal uint32
 	ss            uint16
 	__ssh         uint16
 	fpstate       uintptr
 	oldmask       uint32
 	cr2           uint32
 } /* signal.h:59:1 */
 
 type mcontext_t = struct {
 	gregs   gregset_t
 	fpregs  fpregset_t
 	oldmask uint32
 	cr2     uint32
 } /* signal.h:73:3 */
 
 type __ucontext = struct {
 	uc_flags     uint32
 	uc_link      uintptr
 	uc_stack     stack_t
 	uc_mcontext  mcontext_t
 	uc_sigmask   sigset_t
 	__fpregs_mem [28]uint32
 } /* signal.h:86:9 */
 
 type ucontext_t = __ucontext /* signal.h:93:3 */
 
 type sigval = struct{ sival_int int32 } /* time.h:107:1 */
 
 type siginfo_t = struct {
 	si_signo    int32
 	si_errno    int32
 	si_code     int32
 	__si_fields struct {
 		_     [0]uint32
 		__pad [116]int8
 	}
 } /* signal.h:145:3 */
 
 type sigaction = struct {
 	__sa_handler struct{ sa_handler uintptr }
 	sa_mask      sigset_t
 	sa_flags     int32
 	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:175: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/i386/atomic_arch.h:4:2: assembler statements not supported`)
 	return t
 }
 
 func a_and(tls *TLS, p uintptr, v int32) { /* atomic_arch.h:29:20: */
 	panic(`arch/i386/atomic_arch.h:31:2: assembler statements not supported`)
 }
 
 func a_or(tls *TLS, p uintptr, v int32) { /* atomic_arch.h:37:20: */
 	panic(`arch/i386/atomic_arch.h:39:2: assembler statements not supported`)
 }
 
 func a_ctz_64(tls *TLS, x uint64_t) int32 { /* atomic_arch.h:87:19: */
 	var r int32
 	panic(`arch/i386/atomic_arch.h:90:2: assembler statements not supported`)
 	return r
 }
 
 func a_ctz_32(tls *TLS, x uint32_t) int32 { /* atomic_arch.h:96:19: */
 	var r int32
 	panic(`arch/i386/atomic_arch.h:99:2: assembler statements not supported`)
 	return r
 }
 
 func a_clz_32(tls *TLS, x uint32_t) int32 { /* atomic_arch.h:104:19: */
 	panic(`arch/i386/atomic_arch.h:106:2: assembler statements not supported`)
 	return int32(x)
 }
 
 func a_or_64(tls *TLS, p uintptr, v uint64_t) { /* atomic.h:220:20: */
 	bp := tls.Alloc(8)
 	defer tls.Free(8)
 
 	*(*struct{ v uint64_t })(unsafe.Pointer(bp)) = func() (r struct{ v uint64_t }) {
 		*(*uint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = v
 		return r
 	}()
 	if *(*uint32_t)(unsafe.Pointer(bp)) != 0 {
 		a_or(tls, p, int32(*(*uint32_t)(unsafe.Pointer(bp))))
 	}
 	if *(*uint32_t)(unsafe.Pointer(bp + 1*4)) != 0 {
 		a_or(tls, p+uintptr(1)*4, int32(*(*uint32_t)(unsafe.Pointer(bp + 1*4))))
 	}
 }
 
 type a_cas_p_undefined_but_pointer_not_32bit = [1]int8 /* atomic.h:229:14 */
 
 type __timer = struct {
 	timerid int32
 	thread  pthread_t
 } /* pthread_impl.h:64:1 */
 
 func __pthread_self(tls *TLS) uintptr { /* pthread_arch.h:1:30: */
 	var self uintptr
 	panic(`arch/i386/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 size_t(1)
 	}
 	if uint32(wc) < uint32(0x80) {
 		*(*int8)(unsafe.Pointer(s)) = int8(wc)
 		return size_t(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 Uint32FromInt32(-1)
 		}
 		*(*int8)(unsafe.Pointer(s)) = int8(wc)
 		return size_t(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 size_t(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 size_t(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 size_t(4)
 	}
 	*(*int32)(unsafe.Pointer(X___errno_location(tls))) = 84
 	return Uint32FromInt32(-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 = size_t(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+size_t(1) != 0) {
 					return Uint32FromInt32(-1)
 				}
 				n = n + l
 			} else {
 				n++
 			}
 		}
 		return n
 	}
 	for n >= size_t(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+size_t(1) != 0) {
 				return Uint32FromInt32(-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+size_t(1) != 0) {
 				return Uint32FromInt32(-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(4)
 	defer tls.Free(4)
 	*(*uintptr)(unsafe.Pointer(bp)) = ws
 
 	//TODO return wcsrtombs(s, &(const wchar_t *){ws}, n, 0);
 	return Xwcsrtombs(tls, s, bp, n, 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 ; uintptr_t(s)%uintptr_t(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 = Uint32(Uint32FromInt32(-1)) / size_t(255) * size_t(c)
 	for w = s; !((*(*uint32)(unsafe.Pointer(w))-Uint32(Uint32FromInt32(-1))/size_t(255)) & ^*(*uint32)(unsafe.Pointer(w)) & (Uint32(Uint32FromInt32(-1))/size_t(255)*size_t(255/2+1)) != 0) && !((*(*uint32)(unsafe.Pointer(w))^k-Uint32(Uint32FromInt32(-1))/size_t(255)) & ^(*(*uint32)(unsafe.Pointer(w))^k) & (Uint32(Uint32FromInt32(-1))/size_t(255)*size_t(255/2+1)) != 0); w += 4 {
 	}
 	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+size_t(1))
 	if !(d != 0) {
 		return uintptr(0)
 	}
 	return Xmemcpy(tls, d, s, l+size_t(1))
 }