source: code/trunk/vendor/modernc.org/libc/etc.go@ 823

// Copyright 2020 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.

package libc // import "modernc.org/libc"

import (
        "fmt"
        "io"
        "os"
        "path/filepath"
        "runtime"
        "runtime/debug"
        "sort"
        "strconv"
        "strings"
        "sync"
        "sync/atomic"
        "syscall"
        "time"
        "unsafe"

        "modernc.org/libc/errno"
        "modernc.org/libc/signal"
        "modernc.org/libc/sys/types"
)

const (
        allocatorPageOverhead = 4 * unsafe.Sizeof(int(0))
        stackHeaderSize       = unsafe.Sizeof(stackHeader{})
        stackSegmentSize      = 1<<12 - allocatorPageOverhead
        uintptrSize           = unsafe.Sizeof(uintptr(0))
)

var (
        Covered  = map[uintptr]struct{}{}
        CoveredC = map[string]struct{}{}
        fToken   uintptr
        tid      int32

        atExit   []func()
        atExitMu sync.Mutex

        signals   [signal.NSIG]uintptr
        signalsMu sync.Mutex

        objectMu sync.Mutex
        objects  = map[uintptr]interface{}{}

        tlsBalance int32

        _ = origin
        _ = trc
)

func init() {
        if n := stackHeaderSize; n%16 != 0 {
                panic(fmt.Errorf("internal error: stackHeaderSize %v == %v (mod 16)", n, n%16))
        }
}

func origin(skip int) string {
        pc, fn, fl, _ := runtime.Caller(skip)
        f := runtime.FuncForPC(pc)
        var fns string
        if f != nil {
                fns = f.Name()
                if x := strings.LastIndex(fns, "."); x > 0 {
                        fns = fns[x+1:]
                }
        }
        return fmt.Sprintf("%s:%d:%s", filepath.Base(fn), fl, fns)
}

func trc(s string, args ...interface{}) string { //TODO-
        switch {
        case s == "":
                s = fmt.Sprintf(strings.Repeat("%v ", len(args)), args...)
        default:
                s = fmt.Sprintf(s, args...)
        }
        r := fmt.Sprintf("%s: TRC %s", origin(2), s)
        fmt.Fprintf(os.Stdout, "%s\n", r)
        os.Stdout.Sync()
        return r
}

func todo(s string, args ...interface{}) string { //TODO-
        switch {
        case s == "":
                s = fmt.Sprintf(strings.Repeat("%v ", len(args)), args...)
        default:
                s = fmt.Sprintf(s, args...)
        }
        r := fmt.Sprintf("%s: TODOTODO %s", origin(2), s) //TODOOK
        if dmesgs {
                dmesg("%s", r)
        }
        fmt.Fprintf(os.Stdout, "%s\n", r)
        fmt.Fprintf(os.Stdout, "%s\n", debug.Stack()) //TODO-
        os.Stdout.Sync()
        os.Exit(1)
        panic("unrechable")
}

var coverPCs [1]uintptr //TODO not concurrent safe

func Cover() {
        runtime.Callers(2, coverPCs[:])
        Covered[coverPCs[0]] = struct{}{}
}

func CoverReport(w io.Writer) error {
        var a []string
        pcs := make([]uintptr, 1)
        for pc := range Covered {
                pcs[0] = pc
                frame, _ := runtime.CallersFrames(pcs).Next()
                a = append(a, fmt.Sprintf("%s:%07d:%s", filepath.Base(frame.File), frame.Line, frame.Func.Name()))
        }
        sort.Strings(a)
        _, err := fmt.Fprintf(w, "%s\n", strings.Join(a, "\n"))
        return err
}

func CoverC(s string) {
        CoveredC[s] = struct{}{}
}

func CoverCReport(w io.Writer) error {
        var a []string
        for k := range CoveredC {
                a = append(a, k)
        }
        sort.Strings(a)
        _, err := fmt.Fprintf(w, "%s\n", strings.Join(a, "\n"))
        return err
}

func token() uintptr { return atomic.AddUintptr(&fToken, 1) }

func addObject(o interface{}) uintptr {
        t := token()
        objectMu.Lock()
        objects[t] = o
        objectMu.Unlock()
        return t
}

func getObject(t uintptr) interface{} {
        objectMu.Lock()
        o := objects[t]
        if o == nil {
                panic(todo("", t))
        }

        objectMu.Unlock()
        return o
}

func removeObject(t uintptr) {
        objectMu.Lock()
        if _, ok := objects[t]; !ok {
                panic(todo(""))
        }

        delete(objects, t)
        objectMu.Unlock()
}

func (t *TLS) setErrno(err interface{}) {
        if memgrind {
                if atomic.SwapInt32(&t.reentryGuard, 1) != 0 {
                        panic(todo("concurrent use of TLS instance %p", t))
                }

                defer func() {
                        if atomic.SwapInt32(&t.reentryGuard, 0) != 1 {
                                panic(todo("concurrent use of TLS instance %p", t))
                        }
                }()
        }
        // if dmesgs {
        //      dmesg("%v: %T(%v)\n%s", origin(1), err, err, debug.Stack())
        // }
again:
        switch x := err.(type) {
        case int:
                *(*int32)(unsafe.Pointer(t.errnop)) = int32(x)
        case int32:
                *(*int32)(unsafe.Pointer(t.errnop)) = x
        case *os.PathError:
                err = x.Err
                goto again
        case syscall.Errno:
                *(*int32)(unsafe.Pointer(t.errnop)) = int32(x)
        case *os.SyscallError:
                err = x.Err
                goto again
        default:
                panic(todo("%T", x))
        }
}

// Close frees the resources of t.
func (t *TLS) Close() {
        t.Free(int(unsafe.Sizeof(int32(0))))
        if memgrind {
                if t.stackHeaderBalance != 0 {
                        panic(todo("non zero stack header balance: %d", t.stackHeaderBalance))
                }

                atomic.AddInt32(&tlsBalance, -1)
        }
        t.pthreadData.close(t)
        *t = TLS{}
}

// Alloc allocates n bytes of thread-local storage. It must be paired with a
// call to t.Free(n), using the same n. The order matters. This is ok:
//
//      t.Alloc(11)
//              t.Alloc(22)
//              t.Free(22)
//      t.Free(11)
//
// This is not correct:
//
//      t.Alloc(11)
//              t.Alloc(22)
//              t.Free(11)
//      t.Free(22)
func (t *TLS) Alloc(n int) (r uintptr) {
        if memgrind {
                if atomic.SwapInt32(&t.reentryGuard, 1) != 0 {
                        panic(todo("concurrent use of TLS instance %p", t))
                }

                defer func() {
                        if atomic.SwapInt32(&t.reentryGuard, 0) != 1 {
                                panic(todo("concurrent use of TLS instance %p", t))
                        }
                }()
        }
        n += 15
        n &^= 15
        if t.stack.free >= n {
                r = t.stack.sp
                t.stack.free -= n
                t.stack.sp += uintptr(n)
                return r
        }
        //if we have a next stack
        if nstack := t.stack.next; nstack != 0 {
                if (*stackHeader)(unsafe.Pointer(nstack)).free >= n {
                        *(*stackHeader)(unsafe.Pointer(t.stack.page)) = t.stack
                        t.stack = *(*stackHeader)(unsafe.Pointer(nstack))
                        r = t.stack.sp
                        t.stack.free -= n
                        t.stack.sp += uintptr(n)
                        return r
                }
                nstack := *(*stackHeader)(unsafe.Pointer(t.stack.next))
                for ; ; nstack = *(*stackHeader)(unsafe.Pointer(nstack.next)) {
                        if memgrind {
                                if atomic.AddInt32(&t.stackHeaderBalance, -1) < 0 {
                                        panic(todo("negative stack header balance"))
                                }
                        }
                        Xfree(t, nstack.page)
                        if nstack.next == 0 {
                                break
                        }
                }
                t.stack.next = 0
        }

        if t.stack.page != 0 {
                *(*stackHeader)(unsafe.Pointer(t.stack.page)) = t.stack
        }

        rq := n + int(stackHeaderSize)
        if rq%int(stackSegmentSize) != 0 {
                rq -= rq % int(stackSegmentSize)
                rq += int(stackSegmentSize)
        }
        t.stack.free = rq - int(stackHeaderSize)
        t.stack.prev = t.stack.page

        rq += 15
        rq &^= 15
        t.stack.page = Xmalloc(t, types.Size_t(rq))
        if t.stack.page == 0 {
                panic("OOM")
        }

        if memgrind {
                atomic.AddInt32(&t.stackHeaderBalance, 1)
        }
        t.stack.sp = t.stack.page + stackHeaderSize

        r = t.stack.sp
        t.stack.free -= n
        t.stack.sp += uintptr(n)
        if t.stack.prev != 0 {
                (*stackHeader)(unsafe.Pointer(t.stack.prev)).next = t.stack.page
        }

        return r
}

// this declares how many stack frames are kept alive before being freed
const stackFrameKeepalive = 2

// Free deallocates n bytes of thread-local storage. See TLS.Alloc for details
// on correct usage.
func (t *TLS) Free(n int) {
        if memgrind {
                if atomic.SwapInt32(&t.reentryGuard, 1) != 0 {
                        panic(todo("concurrent use of TLS instance %p", t))
                }

                defer func() {
                        if atomic.SwapInt32(&t.reentryGuard, 0) != 1 {
                                panic(todo("concurrent use of TLS instance %p", t))
                        }
                }()
        }
        n += 15
        n &^= 15
        t.stack.free += n
        t.stack.sp -= uintptr(n)
        if t.stack.sp != t.stack.page+stackHeaderSize {
                return
        }

        nstack := t.stack

        //if we are the first one, just free all of them
        if t.stack.prev == 0 {
                for ; ; nstack = *(*stackHeader)(unsafe.Pointer(nstack.next)) {
                        if memgrind {
                                if atomic.AddInt32(&t.stackHeaderBalance, -1) < 0 {
                                        panic(todo("negative stack header balance"))
                                }
                        }
                        Xfree(t, nstack.page)
                        if nstack.next == 0 {
                                break
                        }
                }
                t.stack = stackHeader{}
                return
        }

        //look if we are in the last n stackframes (n=stackFrameKeepalive)
        //if we find something just return and set the current stack pointer to the previous one
        for i := 0; i < stackFrameKeepalive; i++ {
                if nstack.next == 0 {
                        *((*stackHeader)(unsafe.Pointer(t.stack.page))) = t.stack
                        t.stack = *(*stackHeader)(unsafe.Pointer(t.stack.prev))
                        return
                }
                nstack = *(*stackHeader)(unsafe.Pointer(nstack.next))
        }

        //else only free the last
        if memgrind {
                if atomic.AddInt32(&t.stackHeaderBalance, -1) < 0 {
                        panic(todo("negative stack header balance"))
                }
        }
        Xfree(t, nstack.page)
        (*stackHeader)(unsafe.Pointer(nstack.prev)).next = 0
        *(*stackHeader)(unsafe.Pointer(t.stack.page)) = t.stack
        t.stack = *(*stackHeader)(unsafe.Pointer(t.stack.prev))
}

type stackHeader struct {
        free int     // bytes left in page
        page uintptr // stack page
        prev uintptr // prev stack page = prev stack header
        next uintptr // next stack page = next stack header
        sp   uintptr // next allocation address
        _    stackHeaderPadding
}

func cString(t *TLS, s string) uintptr { //TODO-
        n := len(s)
        p := Xmalloc(t, types.Size_t(n)+1)
        if p == 0 {
                panic("OOM")
        }

        copy((*RawMem)(unsafe.Pointer(p))[:n:n], s)
        *(*byte)(unsafe.Pointer(p + uintptr(n))) = 0
        return p
}

// 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 VaList(p uintptr, args ...interface{}) (r uintptr) {
        if p&7 != 0 {
                panic("internal error")
        }

        r = p
        for _, v := range args {
                switch x := v.(type) {
                case int:
                        *(*int64)(unsafe.Pointer(p)) = int64(x)
                case int32:
                        *(*int64)(unsafe.Pointer(p)) = int64(x)
                case int64:
                        *(*int64)(unsafe.Pointer(p)) = x
                case uint:
                        *(*uint64)(unsafe.Pointer(p)) = uint64(x)
                case uint16:
                        *(*uint64)(unsafe.Pointer(p)) = uint64(x)
                case uint32:
                        *(*uint64)(unsafe.Pointer(p)) = uint64(x)
                case uint64:
                        *(*uint64)(unsafe.Pointer(p)) = x
                case float64:
                        *(*float64)(unsafe.Pointer(p)) = x
                case uintptr:
                        *(*uintptr)(unsafe.Pointer(p)) = x
                default:
                        panic(todo("invalid VaList argument type: %T", x))
                }
                p += 8
        }
        return r
}

// NewVaListN returns a newly allocated va_list for n items. The caller of
// NewVaListN is responsible for freeing the va_list.
func NewVaListN(n int) (va_list uintptr) {
        return Xmalloc(nil, types.Size_t(8*n))
}

// 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 NewVaList(args ...interface{}) (va_list uintptr) {
        return VaList(NewVaListN(len(args)), args...)
}

func VaInt32(app *uintptr) int32 {
        ap := *(*uintptr)(unsafe.Pointer(app))
        if ap == 0 {
                return 0
        }

        ap = roundup(ap, 8)
        v := int32(*(*int64)(unsafe.Pointer(ap)))
        ap += 8
        *(*uintptr)(unsafe.Pointer(app)) = ap
        return v
}

func VaUint32(app *uintptr) uint32 {
        ap := *(*uintptr)(unsafe.Pointer(app))
        if ap == 0 {
                return 0
        }

        ap = roundup(ap, 8)
        v := uint32(*(*uint64)(unsafe.Pointer(ap)))
        ap += 8
        *(*uintptr)(unsafe.Pointer(app)) = ap
        return v
}

func VaInt64(app *uintptr) int64 {
        ap := *(*uintptr)(unsafe.Pointer(app))
        if ap == 0 {
                return 0
        }

        ap = roundup(ap, 8)
        v := *(*int64)(unsafe.Pointer(ap))
        ap += 8
        *(*uintptr)(unsafe.Pointer(app)) = ap
        return v
}

func VaUint64(app *uintptr) uint64 {
        ap := *(*uintptr)(unsafe.Pointer(app))
        if ap == 0 {
                return 0
        }

        ap = roundup(ap, 8)
        v := *(*uint64)(unsafe.Pointer(ap))
        ap += 8
        *(*uintptr)(unsafe.Pointer(app)) = ap
        return v
}

func VaFloat32(app *uintptr) float32 {
        ap := *(*uintptr)(unsafe.Pointer(app))
        if ap == 0 {
                return 0
        }

        ap = roundup(ap, 8)
        v := *(*float64)(unsafe.Pointer(ap))
        ap += 8
        *(*uintptr)(unsafe.Pointer(app)) = ap
        return float32(v)
}

func VaFloat64(app *uintptr) float64 {
        ap := *(*uintptr)(unsafe.Pointer(app))
        if ap == 0 {
                return 0
        }

        ap = roundup(ap, 8)
        v := *(*float64)(unsafe.Pointer(ap))
        ap += 8
        *(*uintptr)(unsafe.Pointer(app)) = ap
        return v
}

func VaUintptr(app *uintptr) uintptr {
        ap := *(*uintptr)(unsafe.Pointer(app))
        if ap == 0 {
                return 0
        }

        ap = roundup(ap, 8)
        v := *(*uintptr)(unsafe.Pointer(ap))
        ap += 8
        *(*uintptr)(unsafe.Pointer(app)) = ap
        return v
}

func roundup(n, to uintptr) uintptr {
        if r := n % to; r != 0 {
                return n + to - r
        }

        return n
}

func GoString(s uintptr) string {
        if s == 0 {
                return ""
        }

        var buf []byte
        for {
                b := *(*byte)(unsafe.Pointer(s))
                if b == 0 {
                        return string(buf)
                }

                buf = append(buf, b)
                s++
        }
}

// GoBytes returns a byte slice from a C char* having length len bytes.
func GoBytes(s uintptr, len int) []byte {
        if len == 0 {
                return nil
        }

        return (*RawMem)(unsafe.Pointer(s))[:len:len]
}

func Bool32(b bool) int32 {
        if b {
                return 1
        }

        return 0
}

func Bool64(b bool) int64 {
        if b {
                return 1
        }

        return 0
}

type sorter struct {
        len  int
        base uintptr
        sz   uintptr
        f    func(*TLS, uintptr, uintptr) int32
        t    *TLS
}

func (s *sorter) Len() int { return s.len }

func (s *sorter) Less(i, j int) bool {
        return s.f(s.t, s.base+uintptr(i)*s.sz, s.base+uintptr(j)*s.sz) < 0
}

func (s *sorter) Swap(i, j int) {
        p := uintptr(s.base + uintptr(i)*s.sz)
        q := uintptr(s.base + uintptr(j)*s.sz)
        for i := 0; i < int(s.sz); i++ {
                *(*byte)(unsafe.Pointer(p)), *(*byte)(unsafe.Pointer(q)) = *(*byte)(unsafe.Pointer(q)), *(*byte)(unsafe.Pointer(p))
                p++
                q++
        }
}

func CString(s string) (uintptr, error) {
        n := len(s)
        p := Xmalloc(nil, types.Size_t(n)+1)
        if p == 0 {
                return 0, fmt.Errorf("CString: cannot allocate %d bytes", n+1)
        }

        copy((*RawMem)(unsafe.Pointer(p))[:n:n], s)
        *(*byte)(unsafe.Pointer(p + uintptr(n))) = 0
        return p, nil
}

func GetEnviron() (r []string) {
        for p := Environ(); ; p += unsafe.Sizeof(p) {
                q := *(*uintptr)(unsafe.Pointer(p))
                if q == 0 {
                        return r
                }

                r = append(r, GoString(q))
        }
}

func strToUint64(t *TLS, s uintptr, base int32) (seenDigits, neg bool, next uintptr, n uint64, err int32) {
        var c byte
out:
        for {
                c = *(*byte)(unsafe.Pointer(s))
                switch c {
                case ' ', '\t', '\n', '\r', '\v', '\f':
                        s++
                case '+':
                        s++
                        break out
                case '-':
                        s++
                        neg = true
                        break out
                default:
                        break out
                }
        }
        for {
                c = *(*byte)(unsafe.Pointer(s))
                var digit uint64
                switch base {
                case 10:
                        switch {
                        case c >= '0' && c <= '9':
                                seenDigits = true
                                digit = uint64(c) - '0'
                        default:
                                return seenDigits, neg, s, n, 0
                        }
                case 16:
                        if c >= 'A' && c <= 'F' {
                                c = c + ('a' - 'A')
                        }
                        switch {
                        case c >= '0' && c <= '9':
                                seenDigits = true
                                digit = uint64(c) - '0'
                        case c >= 'a' && c <= 'f':
                                seenDigits = true
                                digit = uint64(c) - 'a' + 10
                        default:
                                return seenDigits, neg, s, n, 0
                        }
                default:
                        panic(todo("", base))
                }
                n0 := n
                n = uint64(base)*n + digit
                if n < n0 { // overflow
                        return seenDigits, neg, s, n0, errno.ERANGE
                }

                s++
        }
}

func strToFloatt64(t *TLS, s uintptr, bits int) (n float64, errno int32) {
        var b []byte
        var neg bool

        defer func() {
                var err error
                if n, err = strconv.ParseFloat(string(b), bits); err != nil {
                        panic(todo(""))
                }

                if neg {
                        n = -n
                }
        }()

        var c byte
out:
        for {
                c = *(*byte)(unsafe.Pointer(s))
                switch c {
                case ' ', '\t', '\n', '\r', '\v', '\f':
                        s++
                case '+':
                        s++
                        break out
                case '-':
                        s++
                        neg = true
                        break out
                default:
                        break out
                }
        }
        for {
                c = *(*byte)(unsafe.Pointer(s))
                switch {
                case c >= '0' && c <= '9':
                        b = append(b, c)
                case c == '.':
                        b = append(b, c)
                        s++
                        for {
                                c = *(*byte)(unsafe.Pointer(s))
                                switch {
                                case c >= '0' && c <= '9':
                                        b = append(b, c)
                                case c == 'e' || c == 'E':
                                        b = append(b, c)
                                        s++
                                        for {
                                                c = *(*byte)(unsafe.Pointer(s))
                                                switch {
                                                case c == '+' || c == '-':
                                                        b = append(b, c)
                                                        s++
                                                        for {
                                                                c = *(*byte)(unsafe.Pointer(s))
                                                                switch {
                                                                case c >= '0' && c <= '9':
                                                                        b = append(b, c)
                                                                default:
                                                                        return
                                                                }

                                                                s++
                                                        }
                                                default:
                                                        panic(todo("%q %q", b, string(c)))
                                                }
                                        }
                                default:
                                        return
                                }

                                s++
                        }
                default:
                        panic(todo("%q %q", b, string(c)))
                }

                s++
        }
}

func parseZone(s string) (name string, off int) {
        _, name, off, _ = parseZoneOffset(s, false)
        return name, off
}

func parseZoneOffset(s string, offOpt bool) (string, string, int, bool) {
        s0 := s
        name := s
        for len(s) != 0 {
                switch c := s[0]; {
                case c >= 'A' && c <= 'Z', c >= 'a' && c <= 'z', c == '_', c == '/':
                        s = s[1:]
                default:
                        name = name[:len(name)-len(s)]
                        if len(name) < 3 {
                                panic(todo("%q", s0))
                        }

                        if offOpt {
                                if len(s) == 0 {
                                        return "", name, 0, false
                                }

                                if c := s[0]; (c < '0' || c > '9') && c != '+' && c != '-' {
                                        return s, name, 0, false
                                }
                        }

                        s, off := parseOffset(s)
                        return s, name, off, true
                }
        }
        return "", s0, 0, true
}

// [+|-]hh[:mm[:ss]]
func parseOffset(s string) (string, int) {
        if len(s) == 0 {
                panic(todo(""))
        }

        k := 1
        switch s[0] {
        case '+':
                // nop
                s = s[1:]
        case '-':
                k = -1
                s = s[1:]
        }
        s, hh, ok := parseUint(s)
        if !ok {
                panic(todo(""))
        }

        n := hh * 3600
        if len(s) == 0 || s[0] != ':' {
                return s, k * n
        }

        s = s[1:] // ':'
        if len(s) == 0 {
                panic(todo(""))
        }

        s, mm, ok := parseUint(s)
        if !ok {
                panic(todo(""))
        }

        n += mm * 60
        if len(s) == 0 || s[0] != ':' {
                return s, k * n
        }

        s = s[1:] // ':'
        if len(s) == 0 {
                panic(todo(""))
        }

        s, ss, _ := parseUint(s)
        return s, k * (n + ss)
}

func parseUint(s string) (string, int, bool) {
        var ok bool
        var r int
        for len(s) != 0 {
                switch c := s[0]; {
                case c >= '0' && c <= '9':
                        ok = true
                        r0 := r
                        r = 10*r + int(c) - '0'
                        if r < r0 {
                                panic(todo(""))
                        }

                        s = s[1:]
                default:
                        return s, r, ok
                }
        }
        return s, r, ok
}

// https://stackoverflow.com/a/53052382
//
// isTimeDST returns true if time t occurs within daylight saving time
// for its time zone.
func isTimeDST(t time.Time) bool {
        // If the most recent (within the last year) clock change
        // was forward then assume the change was from std to dst.
        hh, mm, _ := t.UTC().Clock()
        tClock := hh*60 + mm
        for m := -1; m > -12; m-- {
                // assume dst lasts for at least one month
                hh, mm, _ := t.AddDate(0, m, 0).UTC().Clock()
                clock := hh*60 + mm
                if clock != tClock {
                        return clock > tClock
                }
        }
        // assume no dst
        return false
}