用户登录和接口鉴权

vendor/github.com/bytedance/sonic/internal/rt/asm_amd64.s

@@ -1,5 +1,4 @@
 // +build !noasm,amd64 !appengine,amd64
-// Code generated by asm2asm, DO NOT EDIT·
 
 #include "go_asm.h"
 #include "funcdata.h"
@@ -18,3 +17,43 @@ _entry:
 _stack_grow:
     CALL runtime·morestack_noctxt<>(SB)
     JMP  _entry
+
+
+TEXT ·StopProf(SB), NOSPLIT, $0-0
+    NO_LOCAL_POINTERS
+    CMPB github·com∕bytedance∕sonic∕internal∕rt·StopProfiling(SB), $0
+    JEQ  _ret_1
+    MOVL $1, AX
+    LEAQ github·com∕bytedance∕sonic∕internal∕rt·yieldCount(SB), CX
+    LOCK
+    XADDL AX, (CX)
+    MOVL runtime·prof+4(SB), AX
+    TESTL AX, AX
+    JEQ _ret_1
+    MOVL AX, github·com∕bytedance∕sonic∕internal∕rt·oldHz(SB)
+    MOVL $0, runtime·prof+4(SB)
+_ret_1:
+    RET
+
+
+TEXT ·StartProf(SB), NOSPLIT, $0-0
+    NO_LOCAL_POINTERS
+    CMPB github·com∕bytedance∕sonic∕internal∕rt·StopProfiling(SB), $0
+    JEQ  _ret_2
+    MOVL $-1, AX
+    LEAQ github·com∕bytedance∕sonic∕internal∕rt·yieldCount(SB), CX
+    LOCK
+    XADDL AX, (CX)
+    CMPL github·com∕bytedance∕sonic∕internal∕rt·yieldCount(SB), $0
+    JNE _ret_2
+    CMPL runtime·prof+4(SB), $0
+    JNE _ret_2
+    CMPL github·com∕bytedance∕sonic∕internal∕rt·oldHz(SB), $0
+    JNE _branch_1
+    MOVL $100, github·com∕bytedance∕sonic∕internal∕rt·oldHz(SB)
+_branch_1:
+    MOVL github·com∕bytedance∕sonic∕internal∕rt·oldHz(SB), AX
+    MOVL AX, runtime·prof+4(SB)
+_ret_2:
+    RET
+    

vendor/github.com/bytedance/sonic/internal/rt/fastmem.go

@@ -17,10 +17,8 @@
 package rt
 
 import (
-	"reflect"
-	"unsafe"
-
-	"github.com/bytedance/sonic/option"
+    `unsafe`
+    `reflect`
 )
 
 //go:nosplit
@@ -92,21 +90,6 @@ func GuardSlice(buf *[]byte, n int) {
 	}
 }
 
-func GuardSlice2(buf []byte, n int) []byte {
-	c := cap(buf)
-	l := len(buf)
-	if c-l < n {
-		c = c>>1 + n + l
-		if c < 32 {
-			c = 32
-		}
-		tmp := make([]byte, l, c)
-		copy(tmp, buf)
-		buf = tmp
-	}
-    return buf
-}
-
 //go:nosplit
 func Ptr2SlicePtr(s unsafe.Pointer, l int, c int) unsafe.Pointer {
     slice := &GoSlice{
@@ -139,17 +122,4 @@ func StrFrom(p unsafe.Pointer, n int64) (s string) {
 func NoEscape(p unsafe.Pointer) unsafe.Pointer {
     x := uintptr(p)
     return unsafe.Pointer(x ^ 0)
-}
-
-//go:nosplit
-func MoreStack(size uintptr)
-
-//go:nosplit
-func Add(ptr unsafe.Pointer, off uintptr) unsafe.Pointer {
-    return unsafe.Pointer(uintptr(ptr) + off)
-}
-
-// CanSizeResue
-func CanSizeResue(cap int) bool {
-    return cap <= int(option.LimitBufferSize)
-}
+}

vendor/github.com/bytedance/sonic/internal/rt/fastvalue.go

@@ -17,179 +17,209 @@
 package rt
 
 import (
-	"reflect"
-	"unsafe"
+    `reflect`
+    `unsafe`
 )
 
 var (
-	reflectRtypeItab = findReflectRtypeItab()
+    reflectRtypeItab = findReflectRtypeItab()
 )
 
 // GoType.KindFlags const
 const (
-	F_direct    = 1 << 5
-	F_kind_mask = (1 << 5) - 1
+    F_direct    = 1 << 5
+    F_kind_mask = (1 << 5) - 1
 )
 
 // GoType.Flags const
 const (
-	tflagUncommon      uint8 = 1 << 0
-	tflagExtraStar     uint8 = 1 << 1
-	tflagNamed         uint8 = 1 << 2
-	tflagRegularMemory uint8 = 1 << 3
+    tflagUncommon      uint8 = 1 << 0
+    tflagExtraStar     uint8 = 1 << 1
+    tflagNamed         uint8 = 1 << 2
+    tflagRegularMemory uint8 = 1 << 3
 )
 
 type GoType struct {
-	Size       uintptr
-	PtrData    uintptr
-	Hash       uint32
-	Flags      uint8
-	Align      uint8
-	FieldAlign uint8
-	KindFlags  uint8
-	Traits     unsafe.Pointer
-	GCData     *byte
-	Str        int32
-	PtrToSelf  int32
+    Size       uintptr
+    PtrData    uintptr
+    Hash       uint32
+    Flags      uint8
+    Align      uint8
+    FieldAlign uint8
+    KindFlags  uint8
+    Traits     unsafe.Pointer
+    GCData     *byte
+    Str        int32
+    PtrToSelf  int32
 }
 
 func (self *GoType) IsNamed() bool {
-	return (self.Flags & tflagNamed) != 0
+    return (self.Flags & tflagNamed) != 0
 }
 
 func (self *GoType) Kind() reflect.Kind {
-	return reflect.Kind(self.KindFlags & F_kind_mask)
+    return reflect.Kind(self.KindFlags & F_kind_mask)
 }
 
 func (self *GoType) Pack() (t reflect.Type) {
-	(*GoIface)(unsafe.Pointer(&t)).Itab = reflectRtypeItab
-	(*GoIface)(unsafe.Pointer(&t)).Value = unsafe.Pointer(self)
-	return
+    (*GoIface)(unsafe.Pointer(&t)).Itab = reflectRtypeItab
+    (*GoIface)(unsafe.Pointer(&t)).Value = unsafe.Pointer(self)
+    return
 }
 
 func (self *GoType) String() string {
-	return self.Pack().String()
+    return self.Pack().String()
 }
 
 func (self *GoType) Indirect() bool {
-	return self.KindFlags&F_direct == 0
+    return self.KindFlags & F_direct == 0
+}
+
+type GoMap struct {
+    Count      int
+    Flags      uint8
+    B          uint8
+    Overflow   uint16
+    Hash0      uint32
+    Buckets    unsafe.Pointer
+    OldBuckets unsafe.Pointer
+    Evacuate   uintptr
+    Extra      unsafe.Pointer
+}
+
+type GoMapIterator struct {
+    K           unsafe.Pointer
+    V           unsafe.Pointer
+    T           *GoMapType
+    H           *GoMap
+    Buckets     unsafe.Pointer
+    Bptr        *unsafe.Pointer
+    Overflow    *[]unsafe.Pointer
+    OldOverflow *[]unsafe.Pointer
+    StartBucket uintptr
+    Offset      uint8
+    Wrapped     bool
+    B           uint8
+    I           uint8
+    Bucket      uintptr
+    CheckBucket uintptr
 }
 
 type GoItab struct {
-	it unsafe.Pointer
-	Vt *GoType
-	hv uint32
-	_  [4]byte
-	fn [1]uintptr
+    it unsafe.Pointer
+    Vt *GoType
+    hv uint32
+    _  [4]byte
+    fn [1]uintptr
 }
 
 type GoIface struct {
-	Itab  *GoItab
-	Value unsafe.Pointer
+    Itab  *GoItab
+    Value unsafe.Pointer
 }
 
 type GoEface struct {
-	Type  *GoType
-	Value unsafe.Pointer
+    Type  *GoType
+    Value unsafe.Pointer
 }
 
 func (self GoEface) Pack() (v interface{}) {
-	*(*GoEface)(unsafe.Pointer(&v)) = self
-	return
+    *(*GoEface)(unsafe.Pointer(&v)) = self
+    return
 }
 
 type GoPtrType struct {
-	GoType
-	Elem *GoType
+    GoType
+    Elem *GoType
 }
 
 type GoMapType struct {
-	GoType
-	Key        *GoType
-	Elem       *GoType
-	Bucket     *GoType
-	Hasher     func(unsafe.Pointer, uintptr) uintptr
-	KeySize    uint8
-	ElemSize   uint8
-	BucketSize uint16
-	Flags      uint32
+    GoType
+    Key        *GoType
+    Elem       *GoType
+    Bucket     *GoType
+    Hasher     func(unsafe.Pointer, uintptr) uintptr
+    KeySize    uint8
+    ElemSize   uint8
+    BucketSize uint16
+    Flags      uint32
 }
 
 func (self *GoMapType) IndirectElem() bool {
-	return self.Flags&2 != 0
+    return self.Flags & 2 != 0
 }
 
 type GoStructType struct {
-	GoType
-	Pkg    *byte
-	Fields []GoStructField
+    GoType
+    Pkg    *byte
+    Fields []GoStructField
 }
 
 type GoStructField struct {
-	Name     *byte
-	Type     *GoType
-	OffEmbed uintptr
+    Name     *byte
+    Type     *GoType
+    OffEmbed uintptr
 }
 
 type GoInterfaceType struct {
-	GoType
-	PkgPath *byte
-	Methods []GoInterfaceMethod
+    GoType
+    PkgPath *byte
+    Methods []GoInterfaceMethod
 }
 
 type GoInterfaceMethod struct {
-	Name int32
-	Type int32
+    Name int32
+    Type int32
 }
 
 type GoSlice struct {
-	Ptr unsafe.Pointer
-	Len int
-	Cap int
+    Ptr unsafe.Pointer
+    Len int
+    Cap int
 }
 
 type GoString struct {
-	Ptr unsafe.Pointer
-	Len int
+    Ptr unsafe.Pointer
+    Len int
 }
 
 func PtrElem(t *GoType) *GoType {
-	return (*GoPtrType)(unsafe.Pointer(t)).Elem
+    return (*GoPtrType)(unsafe.Pointer(t)).Elem
 }
 
 func MapType(t *GoType) *GoMapType {
-	return (*GoMapType)(unsafe.Pointer(t))
+    return (*GoMapType)(unsafe.Pointer(t))
 }
 
 func IfaceType(t *GoType) *GoInterfaceType {
-	return (*GoInterfaceType)(unsafe.Pointer(t))
+    return (*GoInterfaceType)(unsafe.Pointer(t))
 }
 
 func UnpackType(t reflect.Type) *GoType {
-	return (*GoType)((*GoIface)(unsafe.Pointer(&t)).Value)
+    return (*GoType)((*GoIface)(unsafe.Pointer(&t)).Value)
 }
 
 func UnpackEface(v interface{}) GoEface {
-	return *(*GoEface)(unsafe.Pointer(&v))
+    return *(*GoEface)(unsafe.Pointer(&v))
 }
 
 func UnpackIface(v interface{}) GoIface {
-	return *(*GoIface)(unsafe.Pointer(&v))
+    return *(*GoIface)(unsafe.Pointer(&v))
 }
 
 func findReflectRtypeItab() *GoItab {
-	v := reflect.TypeOf(struct{}{})
-	return (*GoIface)(unsafe.Pointer(&v)).Itab
+    v := reflect.TypeOf(struct{}{})
+    return (*GoIface)(unsafe.Pointer(&v)).Itab
 }
 
 func AssertI2I2(t *GoType, i GoIface) (r GoIface) {
-	inter := IfaceType(t)
+    inter := IfaceType(t)
 	tab := i.Itab
 	if tab == nil {
 		return
 	}
 	if (*GoInterfaceType)(tab.it) != inter {
-		tab = GetItab(inter, tab.Vt, true)
+		tab = Getitab(inter, tab.Vt, true)
 		if tab == nil {
 			return
 		}
@@ -199,33 +229,15 @@ func AssertI2I2(t *GoType, i GoIface) (r GoIface) {
 	return
 }
 
-func (t *GoType) IsInt64() bool {
-	return t.Kind() == reflect.Int64 || (t.Kind() == reflect.Int && t.Size == 8)
-}
-
-func (t *GoType) IsInt32() bool {
-	return t.Kind() == reflect.Int32 || (t.Kind() == reflect.Int && t.Size == 4)
-}
-
-//go:nosplit
-func (t *GoType) IsUint64() bool {
-	isUint := t.Kind() == reflect.Uint || t.Kind() == reflect.Uintptr
-	return t.Kind() == reflect.Uint64 || (isUint && t.Size == 8)
-}
-
-//go:nosplit
-func (t *GoType) IsUint32() bool {
-	isUint := t.Kind() == reflect.Uint || t.Kind() == reflect.Uintptr
-	return t.Kind() == reflect.Uint32 || (isUint && t.Size == 4)
-}
-
-//go:nosplit
-func PtrAdd(ptr unsafe.Pointer, offset uintptr) unsafe.Pointer {
-	return unsafe.Pointer(uintptr(ptr) + offset)
-}
-
 //go:noescape
-//go:linkname GetItab runtime.getitab
-func GetItab(inter *GoInterfaceType, typ *GoType, canfail bool) *GoItab
+//go:linkname Getitab runtime.getitab
+func Getitab(inter *GoInterfaceType, typ *GoType, canfail bool) *GoItab
 
 
+func GetFuncPC(fn interface{}) uintptr {
+    ft := UnpackEface(fn)
+    if ft.Type.Kind() != reflect.Func {
+        panic("not a function")
+    }
+    return *(*uintptr)(ft.Value)
+}

vendor/github.com/bytedance/sonic/internal/rt/gcwb.go

@@ -1,5 +1,3 @@
-// +build go1.21,!go1.26
-
 /*
  * Copyright 2021 ByteDance Inc.
  *
@@ -19,18 +17,13 @@
 package rt
 
 import (
+    `os`
     `sync/atomic`
     `unsafe`
 
     `golang.org/x/arch/x86/x86asm`
 )
 
-//go:linkname GcWriteBarrier2 runtime.gcWriteBarrier2
-func GcWriteBarrier2()
-
-//go:linkname RuntimeWriteBarrier runtime.writeBarrier
-var RuntimeWriteBarrier uintptr
-
 const (
     _MaxInstr = 15
 )
@@ -83,3 +76,49 @@ func GcwbAddr() uintptr {
     }
 }
 
+// StopProfiling is used to stop traceback introduced by SIGPROF while native code is running.
+// WARN: this option is only a workaround for traceback issue (https://github.com/bytedance/sonic/issues/310),
+// and will be dropped when the issue is fixed.
+var StopProfiling = os.Getenv("SONIC_STOP_PROFILING") != ""
+
+// WARN: must be aligned with runtime.Prof
+// type Prof struct {
+//     signalLock uint32
+// 	hz int32
+// }
+
+var (
+    // // go:linkname runtimeProf runtime.prof
+    // runtimeProf Prof
+
+    // count of native-C calls
+    yieldCount uint32
+
+    // previous value of runtimeProf.hz
+    oldHz int32
+)
+
+//go:nosplit
+func MoreStack(size uintptr)
+
+func StopProf()
+
+// func StopProf() {
+//     atomic.AddUint32(&yieldCount, 1)
+//     if runtimeProf.hz != 0 {
+//         oldHz = runtimeProf.hz
+//         runtimeProf.hz = 0
+//     }
+// }
+
+func StartProf()
+
+// func StartProf() {
+//     atomic.AddUint32(&yieldCount, ^uint32(0))
+//     if yieldCount == 0 && runtimeProf.hz == 0 {
+//         if oldHz == 0 {
+//             oldHz = 100
+//         }
+//         runtimeProf.hz = oldHz
+//     }
+// }