增加websocket支持

vendor/github.com/bytedance/sonic/internal/encoder/compiler.go

@@ -831,7 +831,7 @@ func (self *_Compiler) compileStructFieldZero(p *_Program, vt reflect.Type) {
         case reflect.Float32   : p.add(_OP_is_zero_4)
         case reflect.Float64   : p.add(_OP_is_zero_8)
         case reflect.String    : p.add(_OP_is_nil_p1)
-        case reflect.Interface : p.add(_OP_is_nil)
+        case reflect.Interface : p.add(_OP_is_nil_p1)
         case reflect.Map       : p.add(_OP_is_zero_map)
         case reflect.Ptr       : p.add(_OP_is_nil)
         case reflect.Slice     : p.add(_OP_is_nil_p1)

vendor/github.com/bytedance/sonic/internal/encoder/encoder.go

@@ -40,8 +40,6 @@ const (
     bitNoQuoteTextMarshaler
     bitNoNullSliceOrMap
     bitValidateString
-    bitNoValidateJSONMarshaler
-    bitNoEncoderNewline 
 
     // used for recursive compile
     bitPointerValue = 63
@@ -73,13 +71,6 @@ const (
     // ValidateString indicates that encoder should validate the input string
     // before encoding it into JSON.
     ValidateString       Options = 1 << bitValidateString
-
-    // NoValidateJSONMarshaler indicates that the encoder should not validate the output string
-    // after encoding the JSONMarshaler to JSON.
-    NoValidateJSONMarshaler Options = 1 << bitNoValidateJSONMarshaler
-
-    // NoEncoderNewline indicates that the encoder should not add a newline after every message
-    NoEncoderNewline Options = 1 << bitNoEncoderNewline
   
     // CompatibleWithStd is used to be compatible with std encoder.
     CompatibleWithStd Options = SortMapKeys | EscapeHTML | CompactMarshaler
@@ -124,25 +115,6 @@ func (self *Encoder) SetValidateString(f bool) {
     }
 }
 
-// SetNoValidateJSONMarshaler specifies if option NoValidateJSONMarshaler opens
-func (self *Encoder) SetNoValidateJSONMarshaler(f bool) {
-    if f {
-        self.Opts |= NoValidateJSONMarshaler
-    } else {
-        self.Opts &= ^NoValidateJSONMarshaler
-    }
-}
-
-// SetNoEncoderNewline specifies if option NoEncoderNewline opens
-func (self *Encoder) SetNoEncoderNewline(f bool) {
-    if f {
-        self.Opts |= NoEncoderNewline
-    } else {
-        self.Opts &= ^NoEncoderNewline
-    }
-}
-
-
 // SetCompactMarshaler specifies if option CompactMarshaler opens
 func (self *Encoder) SetCompactMarshaler(f bool) {
     if f {
@@ -320,6 +292,7 @@ func Pretouch(vt reflect.Type, opts ...option.CompileOption) error {
     cfg := option.DefaultCompileOptions()
     for _, opt := range opts {
         opt(&cfg)
+        break
     }
     return pretouchRec(map[reflect.Type]uint8{vt: 0}, cfg)
 }
@@ -337,7 +310,7 @@ func Valid(data []byte) (ok bool, start int) {
     s := rt.Mem2Str(data)
     p := 0
     m := types.NewStateMachine()
-    ret := native.ValidateOne(&s, &p, m, types.F_VALIDATE_STRING)
+    ret := native.ValidateOne(&s, &p, m)
     types.FreeStateMachine(m)
 
     if ret < 0 {
@@ -352,4 +325,4 @@ func Valid(data []byte) (ok bool, start int) {
     }
 
     return true, ret
-}
+}

vendor/github.com/bytedance/sonic/internal/encoder/stream.go

@@ -36,8 +36,7 @@ func NewStreamEncoder(w io.Writer) *StreamEncoder {
 
 // Encode encodes interface{} as JSON to io.Writer
 func (enc *StreamEncoder) Encode(val interface{}) (err error) {
-    buf := newBytes()
-    out := buf
+    out := newBytes()
 
     /* encode into the buffer */
     err = EncodeInto(&out, val, enc.Opts)
@@ -55,9 +54,7 @@ func (enc *StreamEncoder) Encode(val interface{}) (err error) {
         }
 
         // according to standard library, terminate each value with a newline...
-        if enc.Opts & NoEncoderNewline == 0 {
-            buf.WriteByte('\n')
-        }
+        buf.WriteByte('\n')
 
         /* copy into io.Writer */
         _, err = io.Copy(enc.w, buf)
@@ -78,12 +75,10 @@ func (enc *StreamEncoder) Encode(val interface{}) (err error) {
         }
 
         // according to standard library, terminate each value with a newline...
-        if enc.Opts & NoEncoderNewline == 0 {
-            enc.w.Write([]byte{'\n'})
-        }
+        enc.w.Write([]byte{'\n'})
     }
 
 free_bytes:
-    freeBytes(buf)
+    freeBytes(out)
     return err
-}
+}

vendor/github.com/bytedance/sonic/internal/jit/assembler_amd64.go

@@ -72,6 +72,18 @@ func (self *BaseAssembler) NOPn(n int) {
     }
 }
 
+func (self *BaseAssembler) StorePtr(ptr int64, to obj.Addr, tmp obj.Addr) {
+    if (to.Type != obj.TYPE_MEM) || (tmp.Type != obj.TYPE_REG) {
+        panic("must store imm to memory, tmp must be register")
+    }
+    if (ptr >> 32) != 0 {
+        self.Emit("MOVQ", Imm(ptr), tmp)
+        self.Emit("MOVQ", tmp, to)
+    } else {
+        self.Emit("MOVQ", Imm(ptr), to);
+    }
+}
+
 func (self *BaseAssembler) Byte(v ...byte) {
     for ; len(v) >= 8; v = v[8:] { self.From("QUAD", Imm(rt.Get64(v))) }
     for ; len(v) >= 4; v = v[4:] { self.From("LONG", Imm(int64(rt.Get32(v)))) }

vendor/github.com/bytedance/sonic/internal/jit/runtime.go

@@ -24,6 +24,11 @@ import (
     `github.com/twitchyliquid64/golang-asm/obj`
 )
 
+//go:noescape
+//go:linkname getitab runtime.getitab
+//goland:noinspection ALL
+func getitab(inter *rt.GoType, typ *rt.GoType, canfail bool) *rt.GoItab
+
 func Func(f interface{}) obj.Addr {
     if p := rt.UnpackEface(f); p.Type.Kind() != reflect.Func {
         panic("f is not a function")
@@ -37,7 +42,7 @@ func Type(t reflect.Type) obj.Addr {
 }
 
 func Itab(i *rt.GoType, t reflect.Type) obj.Addr {
-    return Imm(int64(uintptr(unsafe.Pointer(rt.Getitab(rt.IfaceType(i), rt.UnpackType(t), false)))))
+    return Imm(int64(uintptr(unsafe.Pointer(getitab(i, rt.UnpackType(t), false)))))
 }
 
 func Gitab(i *rt.GoItab) obj.Addr {

vendor/github.com/bytedance/sonic/internal/native/dispatch_amd64.go

@@ -24,10 +24,12 @@ import (
     `github.com/bytedance/sonic/internal/native/avx2`
     `github.com/bytedance/sonic/internal/native/sse`
     `github.com/bytedance/sonic/internal/native/types`
-    `github.com/bytedance/sonic/internal/rt`
 )
 
-const MaxFrameSize   uintptr = 400
+const (
+    MaxFrameSize   uintptr = 400
+    BufPaddingSize int     = 64
+)
 
 var (
     S_f64toa uintptr
@@ -59,221 +61,142 @@ var (
     S_skip_number uintptr
 )
 
-var (
-    __Quote func(s unsafe.Pointer, nb int, dp unsafe.Pointer, dn unsafe.Pointer, flags uint64) int
-
-    __Unquote func(s unsafe.Pointer, nb int, dp unsafe.Pointer, ep unsafe.Pointer, flags uint64) int
-
-    __HTMLEscape func(s unsafe.Pointer, nb int, dp unsafe.Pointer, dn unsafe.Pointer) int
-
-    __Value func(s unsafe.Pointer, n int, p int, v unsafe.Pointer, flags uint64) int
-
-    __SkipOne func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer, flags uint64) int
-
-    __SkipOneFast func(s unsafe.Pointer, p unsafe.Pointer) int
-
-    __GetByPath func(s unsafe.Pointer, p unsafe.Pointer, path unsafe.Pointer, m unsafe.Pointer) int
-
-    __ValidateOne func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer, flags uint64) int
-
-    __I64toa func(out unsafe.Pointer, val int64) (ret int)
-
-    __U64toa func(out unsafe.Pointer, val uint64) (ret int)
-
-    __F64toa func(out unsafe.Pointer, val float64) (ret int)
-
-    __F32toa func(out unsafe.Pointer, val float32) (ret int)
-
-    __ValidateUTF8 func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer) (ret int)
-
-    __ValidateUTF8Fast func(s unsafe.Pointer) (ret int)
-)
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func Quote(s unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int, flags uint64) int
 
 //go:nosplit
-func Quote(s unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int, flags uint64) int {
-    return __Quote(rt.NoEscape(unsafe.Pointer(s)), nb, rt.NoEscape(unsafe.Pointer(dp)), rt.NoEscape(unsafe.Pointer(dn)), flags)
-}
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func Unquote(s unsafe.Pointer, nb int, dp unsafe.Pointer, ep *int, flags uint64) int
 
 //go:nosplit
-func Unquote(s unsafe.Pointer, nb int, dp unsafe.Pointer, ep *int, flags uint64) int {
-    return __Unquote(rt.NoEscape(unsafe.Pointer(s)), nb, rt.NoEscape(unsafe.Pointer(dp)), rt.NoEscape(unsafe.Pointer(ep)), flags)
-}
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func HTMLEscape(s unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int) int
 
 //go:nosplit
-func HTMLEscape(s unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int) int {
-    return __HTMLEscape(rt.NoEscape(unsafe.Pointer(s)), nb, rt.NoEscape(unsafe.Pointer(dp)), rt.NoEscape(unsafe.Pointer(dn)))
-}
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func Value(s unsafe.Pointer, n int, p int, v *types.JsonState, flags uint64) int
 
 //go:nosplit
-func Value(s unsafe.Pointer, n int, p int, v *types.JsonState, flags uint64) int {
-    return __Value(rt.NoEscape(unsafe.Pointer(s)), n, p, rt.NoEscape(unsafe.Pointer(v)), flags)
-}
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func SkipOne(s *string, p *int, m *types.StateMachine, flags uint64) int
 
 //go:nosplit
-func SkipOne(s *string, p *int, m *types.StateMachine, flags uint64) int {
-    return __SkipOne(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)), flags)
-}
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func SkipOneFast(s *string, p *int) int
 
 //go:nosplit
-func SkipOneFast(s *string, p *int) int {
-    return __SkipOneFast(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)))
-}
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func GetByPath(s *string, p *int, path *[]interface{}, m *types.StateMachine) int
 
 //go:nosplit
-func GetByPath(s *string, p *int, path *[]interface{}, m *types.StateMachine) int {
-    return __GetByPath(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(path)), rt.NoEscape(unsafe.Pointer(m)))
-}
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func ValidateOne(s *string, p *int, m *types.StateMachine) int
 
 //go:nosplit
-func ValidateOne(s *string, p *int, m *types.StateMachine, flags uint64) int {
-    return __ValidateOne(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)), flags)
-}
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func I64toa(out *byte, val int64) (ret int)
 
 //go:nosplit
-func I64toa(out *byte, val int64) (ret int) {
-    return __I64toa(rt.NoEscape(unsafe.Pointer(out)), val)
-}
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func U64toa(out *byte, val uint64) (ret int)
 
 //go:nosplit
-func U64toa(out *byte, val uint64) (ret int) {
-    return __U64toa(rt.NoEscape(unsafe.Pointer(out)), val)
-}
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func F64toa(out *byte, val float64) (ret int)
 
 //go:nosplit
-func F64toa(out *byte, val float64) (ret int) {
-    return __F64toa(rt.NoEscape(unsafe.Pointer(out)), val)
-}
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func ValidateUTF8(s *string, p *int, m *types.StateMachine) (ret int)
 
 //go:nosplit
-func F32toa(out *byte, val float32) (ret int) {
-    return __F32toa(rt.NoEscape(unsafe.Pointer(out)), val)
-}
-
-//go:nosplit
-func ValidateUTF8(s *string, p *int, m *types.StateMachine) (ret int) {
-    return __ValidateUTF8(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)))
-}
-
-//go:nosplit
-func ValidateUTF8Fast(s *string) (ret int) {
-    return __ValidateUTF8Fast(rt.NoEscape(unsafe.Pointer(s)))
-}
-
-func useSSE() {
-    sse.Use()
-    S_f64toa      = sse.S_f64toa
-    __F64toa      = sse.F_f64toa
-    S_f32toa      = sse.S_f32toa
-    __F64toa      = sse.F_f64toa
-    S_i64toa      = sse.S_i64toa
-    __I64toa      = sse.F_i64toa
-    S_u64toa      = sse.S_u64toa
-    __U64toa      = sse.F_u64toa
-    S_lspace      = sse.S_lspace
-    S_quote       = sse.S_quote
-    __Quote       = sse.F_quote
-    S_unquote     = sse.S_unquote
-    __Unquote     = sse.F_unquote
-    S_value       = sse.S_value
-    __Value       = sse.F_value
-    S_vstring     = sse.S_vstring
-    S_vnumber     = sse.S_vnumber
-    S_vsigned     = sse.S_vsigned
-    S_vunsigned   = sse.S_vunsigned
-    S_skip_one    = sse.S_skip_one
-    __SkipOne     = sse.F_skip_one
-    __SkipOneFast = sse.F_skip_one_fast
-    S_skip_array  = sse.S_skip_array
-    S_skip_object = sse.S_skip_object
-    S_skip_number = sse.S_skip_number
-    S_get_by_path = sse.S_get_by_path
-    __GetByPath   = sse.F_get_by_path
-    __HTMLEscape  = sse.F_html_escape
-    __ValidateOne = sse.F_validate_one
-    __ValidateUTF8= sse.F_validate_utf8
-    __ValidateUTF8Fast = sse.F_validate_utf8_fast
-}
-
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func ValidateUTF8Fast(s *string) (ret int)
 
 func useAVX() {
-    avx.Use()
     S_f64toa      = avx.S_f64toa
-    __F64toa      = avx.F_f64toa
     S_f32toa      = avx.S_f32toa
-    __F64toa      = avx.F_f64toa
     S_i64toa      = avx.S_i64toa
-    __I64toa      = avx.F_i64toa
     S_u64toa      = avx.S_u64toa
-    __U64toa      = avx.F_u64toa
     S_lspace      = avx.S_lspace
     S_quote       = avx.S_quote
-    __Quote       = avx.F_quote
     S_unquote     = avx.S_unquote
-    __Unquote     = avx.F_unquote
     S_value       = avx.S_value
-    __Value       = avx.F_value
     S_vstring     = avx.S_vstring
     S_vnumber     = avx.S_vnumber
     S_vsigned     = avx.S_vsigned
     S_vunsigned   = avx.S_vunsigned
     S_skip_one    = avx.S_skip_one
-    __SkipOne     = avx.F_skip_one
-    __SkipOneFast = avx.F_skip_one_fast
+    S_skip_one_fast = avx.S_skip_one_fast
     S_skip_array  = avx.S_skip_array
     S_skip_object = avx.S_skip_object
     S_skip_number = avx.S_skip_number
     S_get_by_path = avx.S_get_by_path
-    __GetByPath   = avx.F_get_by_path
-    __HTMLEscape  = avx.F_html_escape
-    __ValidateOne = avx.F_validate_one
-    __ValidateUTF8= avx.F_validate_utf8
-    __ValidateUTF8Fast = avx.F_validate_utf8_fast
 }
 
 func useAVX2() {
-    avx2.Use()
     S_f64toa      = avx2.S_f64toa
-    __F64toa      = avx2.F_f64toa
     S_f32toa      = avx2.S_f32toa
-    __F64toa      = avx2.F_f64toa
     S_i64toa      = avx2.S_i64toa
-    __I64toa      = avx2.F_i64toa
     S_u64toa      = avx2.S_u64toa
-    __U64toa      = avx2.F_u64toa
     S_lspace      = avx2.S_lspace
     S_quote       = avx2.S_quote
-    __Quote       = avx2.F_quote
     S_unquote     = avx2.S_unquote
-    __Unquote     = avx2.F_unquote
     S_value       = avx2.S_value
-    __Value       = avx2.F_value
     S_vstring     = avx2.S_vstring
     S_vnumber     = avx2.S_vnumber
     S_vsigned     = avx2.S_vsigned
     S_vunsigned   = avx2.S_vunsigned
     S_skip_one    = avx2.S_skip_one
-    __SkipOne     = avx2.F_skip_one
-    __SkipOneFast = avx2.F_skip_one_fast
+    S_skip_one_fast = avx2.S_skip_one_fast
     S_skip_array  = avx2.S_skip_array
     S_skip_object = avx2.S_skip_object
     S_skip_number = avx2.S_skip_number
     S_get_by_path = avx2.S_get_by_path
-    __GetByPath   = avx2.F_get_by_path
-    __HTMLEscape  = avx2.F_html_escape
-    __ValidateOne = avx2.F_validate_one
-    __ValidateUTF8= avx2.F_validate_utf8
-    __ValidateUTF8Fast = avx2.F_validate_utf8_fast
 }
 
+func useSSE() {
+    S_f64toa = sse.S_f64toa
+    S_f32toa = sse.S_f32toa
+    S_i64toa = sse.S_i64toa
+    S_u64toa = sse.S_u64toa
+    S_lspace = sse.S_lspace
+    S_quote = sse.S_quote
+    S_unquote = sse.S_unquote
+    S_value = sse.S_value
+    S_vstring = sse.S_vstring
+    S_vnumber = sse.S_vnumber
+    S_vsigned = sse.S_vsigned
+    S_vunsigned = sse.S_vunsigned
+    S_skip_one = sse.S_skip_one
+    S_skip_one_fast = sse.S_skip_one_fast
+    S_skip_array = sse.S_skip_array
+    S_skip_object = sse.S_skip_object
+    S_skip_number = sse.S_skip_number
+    S_get_by_path = sse.S_get_by_path
+}
 
 func init() {
- if cpu.HasAVX2 {
-    useAVX2()
- } else if cpu.HasAVX {
-    useAVX()
- } else if cpu.HasSSE {
-    useSSE()
- } else {
-    panic("Unsupported CPU, maybe it's too old to run Sonic.")
- }
+    if cpu.HasAVX2 {
+        useAVX2()
+    } else if cpu.HasAVX {
+        useAVX()
+    } else if cpu.HasSSE {
+        useSSE()
+    } else {
+        panic("Unsupported CPU, maybe it's too old to run Sonic.")
+    }
 }

vendor/github.com/bytedance/sonic/internal/native/types/types.go

@@ -19,7 +19,6 @@ package types
 import (
     `fmt`
     `sync`
-    `unsafe`
 )
 
 type ValueType int
@@ -29,8 +28,6 @@ type SearchingError uint
 // NOTE: !NOT MODIFIED ONLY.
 // This definitions are followed in native/types.h.
 
-const BufPaddingSize int     = 64
-
 const (
     V_EOF     ValueType = 1
     V_NULL    ValueType = 2
@@ -49,23 +46,15 @@ const (
 )
 
 const (
-    // for native.Unquote() flags
     B_DOUBLE_UNQUOTE  = 0
     B_UNICODE_REPLACE = 1
-
-    // for native.Value() flags
-    B_USE_NUMBER      = 1
     B_VALIDATE_STRING = 5
-    B_ALLOW_CONTROL   = 31
 )
 
 const (
     F_DOUBLE_UNQUOTE  = 1 << B_DOUBLE_UNQUOTE
     F_UNICODE_REPLACE = 1 << B_UNICODE_REPLACE
-
-    F_USE_NUMBER      = 1 << B_USE_NUMBER
     F_VALIDATE_STRING = 1 << B_VALIDATE_STRING
-    F_ALLOW_CONTROL   = 1 << B_ALLOW_CONTROL
 )
 
 const (
@@ -147,18 +136,3 @@ func FreeStateMachine(fsm *StateMachine) {
     stackPool.Put(fsm)
 }
 
-const MaxDigitNums = 800
-
-var digitPool = sync.Pool{
-    New: func() interface{} {
-        return (*byte)(unsafe.Pointer(&[MaxDigitNums]byte{}))
-    },
-}
-
-func NewDbuf() *byte {
-    return digitPool.Get().(*byte)
-}
-
-func FreeDbuf(p *byte) {
-    digitPool.Put(p)
-}

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

@@ -1,4 +1,5 @@
-// +build !noasm,amd64 !appengine,amd64
+// +build !noasm !appengine
+// Code generated by asm2asm, DO NOT EDIT·
 
 #include "go_asm.h"
 #include "funcdata.h"

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

@@ -66,16 +66,15 @@ func FuncAddr(f interface{}) unsafe.Pointer {
     }
 }
 
-//go:nocheckptr
 func IndexChar(src string, index int) unsafe.Pointer {
 	return unsafe.Pointer(uintptr((*GoString)(unsafe.Pointer(&src)).Ptr) + uintptr(index))
 }
 
-//go:nocheckptr
 func IndexByte(ptr []byte, index int) unsafe.Pointer {
 	return unsafe.Pointer(uintptr((*GoSlice)(unsafe.Pointer(&ptr)).Ptr) + uintptr(index))
 }
 
+//go:nosplit
 func GuardSlice(buf *[]byte, n int) {
 	c := cap(*buf)
 	l := len(*buf)
@@ -110,16 +109,4 @@ func StrFrom(p unsafe.Pointer, n int64) (s string) {
     (*GoString)(unsafe.Pointer(&s)).Ptr = p
     (*GoString)(unsafe.Pointer(&s)).Len = int(n)
     return
-}
-
-// NoEscape hides a pointer from escape analysis. NoEscape is
-// the identity function but escape analysis doesn't think the
-// output depends on the input. NoEscape is inlined and currently
-// compiles down to zero instructions.
-// USE CAREFULLY!
-//go:nosplit
-//goland:noinspection GoVetUnsafePointer
-func NoEscape(p unsafe.Pointer) unsafe.Pointer {
-    x := uintptr(p)
-    return unsafe.Pointer(x ^ 0)
 }

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

@@ -211,33 +211,3 @@ func findReflectRtypeItab() *GoItab {
     v := reflect.TypeOf(struct{}{})
     return (*GoIface)(unsafe.Pointer(&v)).Itab
 }
-
-func AssertI2I2(t *GoType, i GoIface) (r GoIface) {
-    inter := IfaceType(t)
-	tab := i.Itab
-	if tab == nil {
-		return
-	}
-	if (*GoInterfaceType)(tab.it) != inter {
-		tab = Getitab(inter, tab.Vt, true)
-		if tab == nil {
-			return
-		}
-	}
-	r.Itab = tab
-	r.Value = i.Value
-	return
-}
-
-//go:noescape
-//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/int48.go

@@ -17,12 +17,12 @@
 package rt
 
 const (
-    MinInt48 int64 = -(1 << 47)
-    MaxInt48 int64 = +(1 << 47) - 1
+    MinInt48 = -(1 << 47)
+    MaxInt48 = +(1 << 47) - 1
 )
 
 func PackInt(v int) uint64 {
-    if u := uint64(v); int64(v) < MinInt48 || int64(v) > MaxInt48 {
+    if u := uint64(v); v < MinInt48 || v > MaxInt48 {
         panic("int48 out of range")
     } else {
         return ((u >> 63) << 47) | (u & 0x00007fffffffffff)