From 1a57267a17c2fc17fb6e104846fabc3e363c326c Mon Sep 17 00:00:00 2001 From: Emile Date: Fri, 16 Aug 2024 19:50:26 +0200 Subject: initial commit --- vendor/modernc.org/libc/builtin.go | 443 +++++++++++++++++++++++++++++++++++++ 1 file changed, 443 insertions(+) create mode 100644 vendor/modernc.org/libc/builtin.go (limited to 'vendor/modernc.org/libc/builtin.go') diff --git a/vendor/modernc.org/libc/builtin.go b/vendor/modernc.org/libc/builtin.go new file mode 100644 index 0000000..5582af6 --- /dev/null +++ b/vendor/modernc.org/libc/builtin.go @@ -0,0 +1,443 @@ +// Copyright 2024 The Libc Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//go:build linux && (amd64 || arm64 || loong64) + +package libc // import "modernc.org/libc" + +import ( + "fmt" + "math" + mbits "math/bits" + "os" + "unsafe" + + "modernc.org/mathutil" +) + +func X__builtin_inff(tls *TLS) float32 { + return float32(math.Inf(1)) +} + +func X__builtin_nanf(tls *TLS, s uintptr) float32 { + return float32(math.NaN()) +} + +func X__builtin_printf(tls *TLS, fmt uintptr, va uintptr) (r int32) { + return Xprintf(tls, fmt, va) +} + +func X__builtin_round(tls *TLS, x float64) (r float64) { + return Xround(tls, x) +} + +func X__builtin_roundf(tls *TLS, x float32) (r float32) { + return Xroundf(tls, x) +} + +func X__builtin_expect(t *TLS, exp, c long) long { + return exp +} + +func X__builtin_bzero(t *TLS, s uintptr, n Tsize_t) { + Xbzero(t, s, n) +} + +func X__builtin_abort(t *TLS) { + Xabort(t) +} + +func X__builtin_abs(t *TLS, j int32) int32 { + return Xabs(t, j) +} + +func X__builtin_ctz(t *TLS, n uint32) int32 { + return int32(mbits.TrailingZeros32(n)) +} + +func X__builtin_clz(t *TLS, n uint32) int32 { + return int32(mbits.LeadingZeros32(n)) +} + +func X__builtin_clzl(t *TLS, n ulong) int32 { + return int32(mbits.LeadingZeros64(n)) +} + +func X__builtin_clzll(t *TLS, n uint64) int32 { + return int32(mbits.LeadingZeros64(n)) +} +func X__builtin_constant_p_impl() { panic(todo("internal error: should never be called")) } + +func X__builtin_copysign(t *TLS, x, y float64) float64 { + return Xcopysign(t, x, y) +} + +func X__builtin_copysignf(t *TLS, x, y float32) float32 { + return Xcopysignf(t, x, y) +} + +func X__builtin_copysignl(t *TLS, x, y float64) float64 { + return Xcopysign(t, x, y) +} + +func X__builtin_exit(t *TLS, status int32) { + Xexit(t, status) +} + +func X__builtin_fabs(t *TLS, x float64) float64 { + return Xfabs(t, x) +} + +func X__builtin_fabsf(t *TLS, x float32) float32 { + return Xfabsf(t, x) +} + +func X__builtin_fabsl(t *TLS, x float64) float64 { + return Xfabsl(t, x) +} + +func X__builtin_free(t *TLS, ptr uintptr) { + Xfree(t, ptr) +} + +func X__builtin_getentropy(t *TLS, buf uintptr, n Tsize_t) int32 { + return Xgetentropy(t, buf, n) +} + +func X__builtin_huge_val(t *TLS) float64 { + return math.Inf(1) +} + +func X__builtin_huge_valf(t *TLS) float32 { + return float32(math.Inf(1)) +} + +func X__builtin_inf(t *TLS) float64 { + return math.Inf(1) +} + +func X__builtin_infl(t *TLS) float64 { + return math.Inf(1) +} + +func X__builtin_malloc(t *TLS, size Tsize_t) uintptr { + return Xmalloc(t, size) +} + +func X__builtin_memcmp(t *TLS, s1, s2 uintptr, n Tsize_t) int32 { + return Xmemcmp(t, s1, s2, n) +} + +func X__builtin_nan(t *TLS, s uintptr) float64 { + return math.NaN() +} + +func X__builtin_nanl(t *TLS, s uintptr) float64 { + return math.NaN() +} + +func X__builtin_prefetch(t *TLS, addr, args uintptr) { +} + +func X__builtin_strchr(t *TLS, s uintptr, c int32) uintptr { + return Xstrchr(t, s, c) +} + +func X__builtin_strcmp(t *TLS, s1, s2 uintptr) int32 { + return Xstrcmp(t, s1, s2) +} + +func X__builtin_strcpy(t *TLS, dest, src uintptr) uintptr { + return Xstrcpy(t, dest, src) +} + +func X__builtin_strlen(t *TLS, s uintptr) Tsize_t { + return Xstrlen(t, s) +} + +func X__builtin_trap(t *TLS) { + Xabort(t) +} + +func X__builtin_popcount(t *TLS, x uint32) int32 { + return int32(mbits.OnesCount32(x)) +} + +// int __builtin_popcountl (unsigned long x) +func X__builtin_popcountl(t *TLS, x ulong) int32 { + return int32(mbits.OnesCount64(x)) +} + +// char * __builtin___strcpy_chk (char *dest, const char *src, size_t os); +func X__builtin___strcpy_chk(t *TLS, dest, src uintptr, os Tsize_t) uintptr { + return Xstrcpy(t, dest, src) +} + +func X__builtin_mmap(t *TLS, addr uintptr, length Tsize_t, prot, flags, fd int32, offset Toff_t) uintptr { + return Xmmap(t, addr, length, prot, flags, fd, offset) +} + +// uint16_t __builtin_bswap16 (uint32_t x) +func X__builtin_bswap16(t *TLS, x uint16) uint16 { + return x<<8 | + x>>8 +} + +// uint32_t __builtin_bswap32 (uint32_t x) +func X__builtin_bswap32(t *TLS, x uint32) uint32 { + return x<<24 | + x&0xff00<<8 | + x&0xff0000>>8 | + x>>24 +} + +// uint64_t __builtin_bswap64 (uint64_t x) +func X__builtin_bswap64(t *TLS, x uint64) uint64 { + return x<<56 | + x&0xff00<<40 | + x&0xff0000<<24 | + x&0xff000000<<8 | + x&0xff00000000>>8 | + x&0xff0000000000>>24 | + x&0xff000000000000>>40 | + x>>56 +} + +// bool __builtin_add_overflow (type1 a, type2 b, type3 *res) +func X__builtin_add_overflowInt64(t *TLS, a, b int64, res uintptr) int32 { + r, ovf := mathutil.AddOverflowInt64(a, b) + *(*int64)(unsafe.Pointer(res)) = r + return Bool32(ovf) +} + +// bool __builtin_add_overflow (type1 a, type2 b, type3 *res) +func X__builtin_add_overflowUint32(t *TLS, a, b uint32, res uintptr) int32 { + r := a + b + *(*uint32)(unsafe.Pointer(res)) = r + return Bool32(r < a) +} + +// bool __builtin_add_overflow (type1 a, type2 b, type3 *res) +func X__builtin_add_overflowUint64(t *TLS, a, b uint64, res uintptr) int32 { + r := a + b + *(*uint64)(unsafe.Pointer(res)) = r + return Bool32(r < a) +} + +// bool __builtin_sub_overflow (type1 a, type2 b, type3 *res) +func X__builtin_sub_overflowInt64(t *TLS, a, b int64, res uintptr) int32 { + r, ovf := mathutil.SubOverflowInt64(a, b) + *(*int64)(unsafe.Pointer(res)) = r + return Bool32(ovf) +} + +// bool __builtin_mul_overflow (type1 a, type2 b, type3 *res) +func X__builtin_mul_overflowInt64(t *TLS, a, b int64, res uintptr) int32 { + r, ovf := mathutil.MulOverflowInt64(a, b) + *(*int64)(unsafe.Pointer(res)) = r + return Bool32(ovf) +} + +// bool __builtin_mul_overflow (type1 a, type2 b, type3 *res) +func X__builtin_mul_overflowUint64(t *TLS, a, b uint64, res uintptr) int32 { + hi, lo := mbits.Mul64(a, b) + *(*uint64)(unsafe.Pointer(res)) = lo + return Bool32(hi != 0) +} + +// bool __builtin_mul_overflow (type1 a, type2 b, type3 *res) +func X__builtin_mul_overflowUint128(t *TLS, a, b Uint128, res uintptr) int32 { + r, ovf := a.mulOvf(b) + *(*Uint128)(unsafe.Pointer(res)) = r + return Bool32(ovf) +} + +func X__builtin_unreachable(t *TLS) { + fmt.Fprintf(os.Stderr, "unrechable\n") + os.Stderr.Sync() + Xexit(t, 1) +} + +func X__builtin_snprintf(t *TLS, str uintptr, size Tsize_t, format, args uintptr) int32 { + return Xsnprintf(t, str, size, format, args) +} + +func X__builtin_sprintf(t *TLS, str, format, args uintptr) (r int32) { + return Xsprintf(t, str, format, args) +} + +func X__builtin_memcpy(t *TLS, dest, src uintptr, n Tsize_t) (r uintptr) { + return Xmemcpy(t, dest, src, n) +} + +// void * __builtin___memcpy_chk (void *dest, const void *src, size_t n, size_t os); +func X__builtin___memcpy_chk(t *TLS, dest, src uintptr, n, os Tsize_t) (r uintptr) { + if os != ^Tsize_t(0) && n < os { + Xabort(t) + } + + return Xmemcpy(t, dest, src, n) +} + +func X__builtin_memset(t *TLS, s uintptr, c int32, n Tsize_t) uintptr { + return Xmemset(t, s, c, n) +} + +// void * __builtin___memset_chk (void *s, int c, size_t n, size_t os); +func X__builtin___memset_chk(t *TLS, s uintptr, c int32, n, os Tsize_t) uintptr { + if os < n { + Xabort(t) + } + + return Xmemset(t, s, c, n) +} + +// size_t __builtin_object_size (const void * ptr, int type) +func X__builtin_object_size(t *TLS, p uintptr, typ int32) Tsize_t { + return ^Tsize_t(0) //TODO frontend magic +} + +// int __builtin___sprintf_chk (char *s, int flag, size_t os, const char *fmt, ...); +func X__builtin___sprintf_chk(t *TLS, s uintptr, flag int32, os Tsize_t, format, args uintptr) (r int32) { + return Xsprintf(t, s, format, args) +} + +func X__builtin_vsnprintf(t *TLS, str uintptr, size Tsize_t, format, va uintptr) int32 { + return Xvsnprintf(t, str, size, format, va) +} + +// int __builtin___snprintf_chk(char * str, size_t maxlen, int flag, size_t os, const char * format, ...); +func X__builtin___snprintf_chk(t *TLS, str uintptr, maxlen Tsize_t, flag int32, os Tsize_t, format, args uintptr) (r int32) { + if os != ^Tsize_t(0) && maxlen > os { + Xabort(t) + } + + return Xsnprintf(t, str, maxlen, format, args) +} + +// int __builtin___vsnprintf_chk (char *s, size_t maxlen, int flag, size_t os, const char *fmt, va_list ap); +func X__builtin___vsnprintf_chk(t *TLS, str uintptr, maxlen Tsize_t, flag int32, os Tsize_t, format, args uintptr) (r int32) { + if os != ^Tsize_t(0) && maxlen > os { + Xabort(t) + } + + return Xsnprintf(t, str, maxlen, format, args) +} + +func Xisnan(t *TLS, x float64) int32 { + return X__builtin_isnan(t, x) +} + +func X__isnan(t *TLS, x float64) int32 { + return X__builtin_isnan(t, x) +} + +func X__builtin_isnan(t *TLS, x float64) int32 { + return Bool32(math.IsNaN(x)) +} + +func Xisnanf(t *TLS, arg float32) int32 { + return X__builtin_isnanf(t, arg) +} + +func X__isnanf(t *TLS, arg float32) int32 { + return X__builtin_isnanf(t, arg) +} + +func X__builtin_isnanf(t *TLS, x float32) int32 { + return Bool32(math.IsNaN(float64(x))) +} + +func Xisnanl(t *TLS, arg float64) int32 { + return X__builtin_isnanl(t, arg) +} + +func X__isnanl(t *TLS, arg float64) int32 { + return X__builtin_isnanl(t, arg) +} + +func X__builtin_isnanl(t *TLS, x float64) int32 { + return Bool32(math.IsNaN(x)) +} + +func X__builtin_llabs(tls *TLS, a int64) int64 { + return Xllabs(tls, a) +} + +func X__builtin_log2(t *TLS, x float64) float64 { + return Xlog2(t, x) +} + +func X__builtin___strncpy_chk(t *TLS, dest, src uintptr, n, os Tsize_t) (r uintptr) { + if n != ^Tsize_t(0) && os < n { + Xabort(t) + } + + return Xstrncpy(t, dest, src, n) +} + +func X__builtin___strcat_chk(t *TLS, dest, src uintptr, os Tsize_t) (r uintptr) { + return Xstrcat(t, dest, src) +} + +func X__builtin___memmove_chk(t *TLS, dest, src uintptr, n, os Tsize_t) uintptr { + if os != ^Tsize_t(0) && os < n { + Xabort(t) + } + + return Xmemmove(t, dest, src, n) +} + +func X__builtin_isunordered(t *TLS, a, b float64) int32 { + return Bool32(math.IsNaN(a) || math.IsNaN(b)) +} + +func X__builtin_ffs(tls *TLS, i int32) (r int32) { + return Xffs(tls, i) +} + +func X__builtin_rintf(tls *TLS, x float32) (r float32) { + return Xrintf(tls, x) +} + +func X__builtin_lrintf(tls *TLS, x float32) (r long) { + return Xlrintf(tls, x) +} + +func X__builtin_lrint(tls *TLS, x float64) (r long) { + return Xlrint(tls, x) +} + +// double __builtin_fma(double x, double y, double z); +func X__builtin_fma(tls *TLS, x, y, z float64) (r float64) { + return math.FMA(x, y, z) +} + +func X__builtin_alloca(tls *TLS, size Tsize_t) uintptr { + return Xalloca(tls, size) +} + +func X__builtin_isprint(tls *TLS, c int32) (r int32) { + return Xisprint(tls, c) +} + +func X__builtin_isblank(tls *TLS, c int32) (r int32) { + return Xisblank(tls, c) +} + +func X__builtin_trunc(tls *TLS, x float64) (r float64) { + return Xtrunc(tls, x) +} + +func X__builtin_hypot(tls *TLS, x float64, y float64) (r float64) { + return Xhypot(tls, x, y) +} + +func X__builtin_fmax(tls *TLS, x float64, y float64) (r float64) { + return Xfmax(tls, x, y) +} + +func X__builtin_fmin(tls *TLS, x float64, y float64) (r float64) { + return Xfmin(tls, x, y) +} -- cgit 1.4.1