[chore]: Bump github.com/gin-contrib/cors from 1.5.0 to 1.7.0 (#2745)

vendor/github.com/bytedance/sonic/internal/decoder/asm_stubs_amd64_go121.go

@@ -1,4 +1,4 @@
-// +build go1.21,!go1.22
+// +build go1.21,!go1.23
 
 // Copyright 2023 CloudWeGo Authors
 //

vendor/github.com/bytedance/sonic/internal/decoder/assembler_regabi_amd64.go

@@ -1,5 +1,4 @@
-//go:build go1.17 && !go1.22
-// +build go1.17,!go1.22
+// +build go1.17,!go1.23
 
 /*
  * Copyright 2021 ByteDance Inc.
@@ -420,9 +419,9 @@ func (self *_Assembler) call_go(fn obj.Addr) {
 }
 
 func (self *_Assembler) callc(fn obj.Addr) {
-    self.Emit("XCHGQ", _IP, _BP)
+    self.save(_IP)
     self.call(fn)
-    self.Emit("XCHGQ", _IP, _BP)
+    self.load(_IP)
 }
 
 func (self *_Assembler) call_c(fn obj.Addr) {
@@ -1164,7 +1163,7 @@ var (
 
 var (
     _F_FieldMap_GetCaseInsensitive obj.Addr
-    _Empty_Slice = make([]byte, 0)
+    _Empty_Slice = []byte{}
     _Zero_Base = int64(uintptr(((*rt.GoSlice)(unsafe.Pointer(&_Empty_Slice))).Ptr))
 )
 
@@ -1641,7 +1640,8 @@ func (self *_Assembler) _asm_OP_check_empty(p *_Instr) {
         self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm(int64(rbracket))) // CMPB    (IP)(IC), ']'
         self.Sjmp("JNE" , "_not_empty_array_{n}")                            // JNE     _not_empty_array_{n}
         self.Emit("MOVQ", _AX, _IC)                                          // MOVQ    AX, IC
-        self.StorePtr(_Zero_Base, jit.Ptr(_VP, 0), _AX)                      // MOVQ    $zerobase, (VP)
+        self.Emit("MOVQ", jit.Imm(_Zero_Base), _AX)
+        self.WritePtrAX(9, jit.Ptr(_VP, 0), false)
         self.Emit("PXOR", _X0, _X0)                                          // PXOR    X0, X0
         self.Emit("MOVOU", _X0, jit.Ptr(_VP, 8))                             // MOVOU   X0, 8(VP)
         self.Xjmp("JMP" , p.vi())                                            // JMP     {p.vi()}

vendor/github.com/bytedance/sonic/internal/decoder/assembler_stkabi_amd64.go

@@ -1651,7 +1651,8 @@ func (self *_Assembler) _asm_OP_check_empty(p *_Instr) {
         self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm(int64(rbracket))) // CMPB    (IP)(IC), ']'
         self.Sjmp("JNE" , "_not_empty_array_{n}")                            // JNE     _not_empty_array_{n}
         self.Emit("MOVQ", _AX, _IC)                                          // MOVQ    AX, IC
-        self.StorePtr(_Zero_Base, jit.Ptr(_VP, 0), _AX)                      // MOVQ    $zerobase, (VP)
+        self.Emit("MOVQ", jit.Imm(_Zero_Base), _AX)
+        self.WritePtrAX(9, jit.Ptr(_VP, 0), false)
         self.Emit("PXOR" , _X0, _X0)                                         // PXOR    X0, X0
         self.Emit("MOVOU", _X0, jit.Ptr(_VP, 8))                             // MOVOU   X0, 8(VP)
         self.Xjmp("JMP" , p.vi())                                            // JMP     {p.vi()}

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

@@ -527,6 +527,38 @@ func (self *_Compiler) compile(vt reflect.Type) (ret _Program, err error) {
     return
 }
 
+func (self *_Compiler) checkMarshaler(p *_Program, vt reflect.Type) bool {
+    pt := reflect.PtrTo(vt)
+
+    /* check for `json.Unmarshaler` with pointer receiver */
+    if pt.Implements(jsonUnmarshalerType) {
+        p.rtt(_OP_unmarshal_p, pt)
+        return true
+    }
+
+    /* check for `json.Unmarshaler` */
+    if vt.Implements(jsonUnmarshalerType) {
+        p.add(_OP_lspace)
+        self.compileUnmarshalJson(p, vt)
+        return true
+    }
+
+    /* check for `encoding.TextMarshaler` with pointer receiver */
+    if pt.Implements(encodingTextUnmarshalerType) {
+        p.add(_OP_lspace)
+        self.compileUnmarshalTextPtr(p, pt)
+        return true
+    }
+
+    /* check for `encoding.TextUnmarshaler` */
+    if vt.Implements(encodingTextUnmarshalerType) {
+        p.add(_OP_lspace)
+        self.compileUnmarshalText(p, vt)
+        return true
+    }
+    return false
+}
+
 func (self *_Compiler) compileOne(p *_Program, sp int, vt reflect.Type) {
     /* check for recursive nesting */
     ok := self.tab[vt]
@@ -535,32 +567,7 @@ func (self *_Compiler) compileOne(p *_Program, sp int, vt reflect.Type) {
         return
     }
 
-    pt := reflect.PtrTo(vt)
-
-    /* check for `json.Unmarshaler` with pointer receiver */
-    if pt.Implements(jsonUnmarshalerType) {
-        p.rtt(_OP_unmarshal_p, pt)
-        return
-    }
-
-    /* check for `json.Unmarshaler` */
-    if vt.Implements(jsonUnmarshalerType) {
-        p.add(_OP_lspace)
-        self.compileUnmarshalJson(p, vt)
-        return
-    }
-
-    /* check for `encoding.TextMarshaler` with pointer receiver */
-    if pt.Implements(encodingTextUnmarshalerType) {
-        p.add(_OP_lspace)
-        self.compileUnmarshalTextPtr(p, pt)
-        return
-    }
-
-    /* check for `encoding.TextUnmarshaler` */
-    if vt.Implements(encodingTextUnmarshalerType) {
-        p.add(_OP_lspace)
-        self.compileUnmarshalText(p, vt)
+    if self.checkMarshaler(p, vt) {
         return
     }
 
@@ -683,17 +690,9 @@ func (self *_Compiler) compilePtr(p *_Program, sp int, et reflect.Type) {
 
     /* dereference all the way down */
     for et.Kind() == reflect.Ptr {
-        if et.Implements(jsonUnmarshalerType) {
-            p.rtt(_OP_unmarshal_p, et)
+        if self.checkMarshaler(p, et) {
             return
         }
-
-        if et.Implements(encodingTextUnmarshalerType) {
-            p.add(_OP_lspace)
-            self.compileUnmarshalTextPtr(p, et)
-            return
-        }
-
         et = et.Elem()
         p.rtt(_OP_deref, et)
     }
@@ -706,7 +705,7 @@ func (self *_Compiler) compilePtr(p *_Program, sp int, et reflect.Type) {
         /* enter the recursion */
         p.add(_OP_lspace)
         self.tab[et] = true
-        
+
         /* not inline the pointer type
         * recursing the defined pointer type's elem will casue issue379.
         */
@@ -716,8 +715,12 @@ func (self *_Compiler) compilePtr(p *_Program, sp int, et reflect.Type) {
 
     j := p.pc()
     p.add(_OP_goto)
+
+    // set val pointer as nil
     p.pin(i)
     p.add(_OP_nil_1)
+
+    // nothing todo
     p.pin(j)
 }
 

vendor/github.com/bytedance/sonic/internal/decoder/generic_regabi_amd64.go

@@ -1,4 +1,4 @@
-// +build go1.17,!go1.22
+// +build go1.17,!go1.23
 
 /*
  * Copyright 2021 ByteDance Inc.
@@ -119,9 +119,9 @@ func (self *_ValueDecoder) call_go(fn obj.Addr) {
 }
 
 func (self *_ValueDecoder) callc(fn obj.Addr) {
-    self.Emit("XCHGQ", _IP, _BP)
+    self.save(_IP)  
     self.call(fn)
-    self.Emit("XCHGQ", _IP, _BP)
+    self.load(_IP)  
 }
 
 func (self *_ValueDecoder) call_c(fn obj.Addr) {

vendor/github.com/bytedance/sonic/internal/decoder/generic_regabi_amd64_test.s

@@ -1,4 +1,4 @@
-// +build go1.17,!go1.22
+// +build go1.17,!go1.23
 
 //
 // Copyright 2021 ByteDance Inc.

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

@@ -23,11 +23,12 @@ import (
 
     `github.com/bytedance/sonic/internal/native`
     `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
     `github.com/bytedance/sonic/option`
 )
 
 var (
-    minLeftBufferShift   uint = 1
+    minLeftBufferShift uint = 1
 )
 
 // StreamDecoder is the decoder context object for streaming input.
@@ -58,95 +59,71 @@ func NewStreamDecoder(r io.Reader) *StreamDecoder {
 // Either io error from underlying io.Reader (except io.EOF) 
 // or syntax error from data will be recorded and stop subsequently decoding.
 func (self *StreamDecoder) Decode(val interface{}) (err error) {
-    if self.err != nil {
-        return self.err
-    }
-
-    var buf = self.buf[self.scanp:]
-    var p = 0
-    var recycle bool
-    if cap(buf) == 0 {
-        buf = bufPool.Get().([]byte)
-        recycle = true
-    }
-    
-    var first = true
-    var repeat = true
-
-read_more:
-    for {
-        l := len(buf)
-        realloc(&buf)
-        n, err := self.r.Read(buf[l:cap(buf)])
-        buf = buf[:l+n]
-        if err != nil {
-            repeat = false
-            if err == io.EOF {
-                if len(buf) == 0 {
-                    return err
-                }
-                break
-            }
-            self.err = err
-            return err
-        }
-        if n > 0 || first {
-            break
-        }
-    }
-    first = false
-
-    l := len(buf)
-    if l > 0 {
-        self.Decoder.Reset(string(buf))
-
-        var x int
-        if ret := native.SkipOneFast(&self.s, &x); ret < 0 {
-            if repeat {
-                goto read_more
+    // read more data into buf
+    if self.More() {
+        // println(string(self.buf))
+        var s = self.scanp
+    try_skip:
+        var e = len(self.buf)
+        // println("s:", s, "e:", e, "scanned:",self.scanned, "scanp:",self.scanp, self.buf)
+        var src = rt.Mem2Str(self.buf[s:e])
+        // if len(src) > 5 {
+        //     println(src[:5], src[len(src)-5:])
+        // } else {
+        //     println(src)
+        // }
+        // try skip
+        var x = 0;
+        if y := native.SkipOneFast(&src, &x); y < 0 {
+            if self.readMore()  {
+                // println("more")
+                goto try_skip
             } else {
-                err = SyntaxError{x, self.s, types.ParsingError(-ret), ""}
-                self.err = err
+                // println("no more")
+                err = SyntaxError{e, self.s, types.ParsingError(-s), ""}
+                self.setErr(err)
                 return
             }
+        } else {
+            s = y + s
+            e = x + s
         }
-
+        
+        // println("decode: ", s, e)
+        // must copy string here for safety
+        self.Decoder.Reset(string(self.buf[s:e]))
         err = self.Decoder.Decode(val)
         if err != nil {
-            self.err = err
+            self.setErr(err)
+            return 
         }
 
-        p = self.Decoder.Pos()
-        self.scanned += int64(p)
+        self.scanp = e
+        _, empty := self.scan()
+        if empty {
+            // println("recycle")
+            // no remain valid bytes, thus we just recycle buffer
+            mem := self.buf
+            self.buf = nil
+            bufPool.Put(mem[:0])
+        } else {
+            // println("keep")
+            // remain undecoded bytes, move them onto head
+            n := copy(self.buf, self.buf[self.scanp:])
+            self.buf = self.buf[:n]
+        }   
+
+        self.scanned += int64(self.scanp)
         self.scanp = 0
-    }
-    
-    if l > p {
-        // remain undecoded bytes, so copy them into self.buf
-        self.buf = append(self.buf[:0], buf[p:]...)
-    } else {
-        self.buf = nil
-        recycle = true
-    }
+    }    
 
-    if recycle {
-        buf = buf[:0]
-        bufPool.Put(buf)
-    }
-    return err
-}
-
-func (self StreamDecoder) repeatable(err error) bool {
-    if ee, ok := err.(SyntaxError); ok && 
-    (ee.Code == types.ERR_EOF || (ee.Code == types.ERR_INVALID_CHAR && self.i >= len(self.s)-1)) {
-        return true
-    }
-    return false
+    return self.err
 }
 
 // InputOffset returns the input stream byte offset of the current decoder position. 
 // The offset gives the location of the end of the most recently returned token and the beginning of the next token.
 func (self *StreamDecoder) InputOffset() int64 {
+    // println("input offset",self.scanned, self.scanp)
     return self.scanned + int64(self.scanp)
 }
 
@@ -166,28 +143,72 @@ func (self *StreamDecoder) More() bool {
     return err == nil && c != ']' && c != '}'
 }
 
+// More reports whether there is another element in the
+// current array or object being parsed.
+func (self *StreamDecoder) readMore() bool {
+    if self.err != nil {
+        return false
+    }
+
+    var err error
+    var n int
+    for {
+        // Grow buffer if not large enough.
+        l := len(self.buf)
+        realloc(&self.buf)
+
+        n, err = self.r.Read(self.buf[l:cap(self.buf)])
+        self.buf = self.buf[: l+n]
+
+        self.scanp = l
+        _, empty := self.scan()
+        if !empty {
+            return true
+        }
+
+        // buffer has been scanned, now report any error
+        if err != nil  {
+            self.setErr(err)
+            return false
+        }
+    }
+}
+
+func (self *StreamDecoder) setErr(err error) {
+    self.err = err
+    mem := self.buf[:0]
+    self.buf = nil
+    bufPool.Put(mem)
+}
+
 func (self *StreamDecoder) peek() (byte, error) {
     var err error
     for {
-        for i := self.scanp; i < len(self.buf); i++ {
-            c := self.buf[i]
-            if isSpace(c) {
-                continue
-            }
-            self.scanp = i
-            return c, nil
+        c, empty := self.scan()
+        if !empty {
+            return byte(c), nil
         }
         // buffer has been scanned, now report any error
         if err != nil {
-            if err != io.EOF {
-                self.err = err
-            }
+            self.setErr(err)
             return 0, err
         }
         err = self.refill()
     }
 }
 
+func (self *StreamDecoder) scan() (byte, bool) {
+    for i := self.scanp; i < len(self.buf); i++ {
+        c := self.buf[i]
+        if isSpace(c) {
+            continue
+        }
+        self.scanp = i
+        return c, false
+    }
+    return 0, true
+}
+
 func isSpace(c byte) bool {
     return types.SPACE_MASK & (1 << c) != 0
 }
@@ -212,17 +233,25 @@ func (self *StreamDecoder) refill() error {
     return err
 }
 
-func realloc(buf *[]byte) {
+func realloc(buf *[]byte) bool {
     l := uint(len(*buf))
     c := uint(cap(*buf))
+    if c == 0 {
+        // println("use pool!")
+       *buf = bufPool.Get().([]byte)
+       return true
+    }
     if c - l <= c >> minLeftBufferShift {
+        // println("realloc!")
         e := l+(l>>minLeftBufferShift)
-        if e < option.DefaultDecoderBufferSize {
-            e = option.DefaultDecoderBufferSize
+        if e <= c {
+            e = c*2
         }
         tmp := make([]byte, l, e)
         copy(tmp, *buf)
         *buf = tmp
+        return true
     }
+    return false
 }
 

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

@@ -1,4 +1,4 @@
-// +build go1.21,!go1.22
+// +build go1.21,!go1.23
 
 // Copyright 2023 CloudWeGo Authors
 //

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

@@ -1,5 +1,4 @@
-//go:build go1.17 && !go1.22
-// +build go1.17,!go1.22
+// +build go1.17,!go1.23
 
 /*
  * Copyright 2021 ByteDance Inc.
@@ -171,7 +170,7 @@ var (
 )
 
 var (
-    _REG_ffi = []obj.Addr{ _RP, _RL, _RC}
+    _REG_ffi = []obj.Addr{ _RP, _RL, _RC, _SP_q}
     _REG_b64 = []obj.Addr{_SP_p, _SP_q}
 
     _REG_all = []obj.Addr{_ST, _SP_x, _SP_f, _SP_p, _SP_q, _RP, _RL, _RC}
@@ -510,11 +509,9 @@ func (self *_Assembler) call_b64(pc obj.Addr) {
 
 func (self *_Assembler) call_c(pc obj.Addr) {
     self.Emit("XCHGQ", _SP_p, _BX)
-    self.Emit("XCHGQ", _SP_q, _BP)
     self.call(pc)               // CALL $pc
     self.xload(_REG_ffi...)     // LOAD $REG_ffi
     self.Emit("XCHGQ", _SP_p, _BX)
-    self.Emit("XCHGQ", _SP_q, _BP)
 }
 
 func (self *_Assembler) call_go(pc obj.Addr) {

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_p1)
+        case reflect.Interface : p.add(_OP_is_nil)
         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/debug_go117.go

@@ -1,4 +1,4 @@
-// +build go1.17,!go1.22
+// +build go1.17,!go1.23
 
 /*
  * Copyright 2021 ByteDance Inc.

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

@@ -41,6 +41,7 @@ const (
     bitNoNullSliceOrMap
     bitValidateString
     bitNoValidateJSONMarshaler
+    bitNoEncoderNewline 
 
     // used for recursive compile
     bitPointerValue = 63
@@ -76,6 +77,9 @@ const (
     // 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
@@ -129,6 +133,16 @@ func (self *Encoder) SetNoValidateJSONMarshaler(f bool) {
     }
 }
 
+// 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 {

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

@@ -154,17 +154,17 @@ var (
 )
 
 var (
-    _F_assertI2I = jit.Func(assertI2I)
+    _F_assertI2I = jit.Func(rt.AssertI2I2)
 )
 
 func asText(v unsafe.Pointer) (string, error) {
-    text := assertI2I(_T_encoding_TextMarshaler, *(*rt.GoIface)(v))
+    text := rt.AssertI2I2(_T_encoding_TextMarshaler, *(*rt.GoIface)(v))
     r, e := (*(*encoding.TextMarshaler)(unsafe.Pointer(&text))).MarshalText()
     return rt.Mem2Str(r), e
 }
 
 func asJson(v unsafe.Pointer) (string, error) {
-    text := assertI2I(_T_json_Marshaler, *(*rt.GoIface)(v))
+    text := rt.AssertI2I2(_T_json_Marshaler, *(*rt.GoIface)(v))
     r, e := (*(*json.Marshaler)(unsafe.Pointer(&text))).MarshalJSON()
     return rt.Mem2Str(r), e
 }

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

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

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

@@ -38,10 +38,6 @@ func memmove(to unsafe.Pointer, from unsafe.Pointer, n uintptr)
 //goland:noinspection GoUnusedParameter
 func growslice(et *rt.GoType, old rt.GoSlice, cap int) rt.GoSlice
 
-//go:linkname assertI2I runtime.assertI2I
-//goland:noinspection GoUnusedParameter
-func assertI2I(inter *rt.GoType, i rt.GoIface) rt.GoIface
-
 //go:linkname mapiternext runtime.mapiternext
 //goland:noinspection GoUnusedParameter
 func mapiternext(it *rt.GoMapIterator)

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

@@ -38,10 +38,6 @@ func memmove(to unsafe.Pointer, from unsafe.Pointer, n uintptr)
 //goland:noinspection GoUnusedParameter
 func growslice(et *rt.GoType, old rt.GoSlice, cap int) rt.GoSlice
 
-//go:linkname assertI2I runtime.assertI2I2
-//goland:noinspection GoUnusedParameter
-func assertI2I(inter *rt.GoType, i rt.GoIface) rt.GoIface
-
 //go:linkname mapiternext runtime.mapiternext
 //goland:noinspection GoUnusedParameter
 func mapiternext(it *rt.GoMapIterator)

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

@@ -38,10 +38,6 @@ func memmove(to unsafe.Pointer, from unsafe.Pointer, n uintptr)
 //goland:noinspection GoUnusedParameter
 func growslice(et *rt.GoType, old rt.GoSlice, cap int) rt.GoSlice
 
-//go:linkname assertI2I runtime.assertI2I2
-//goland:noinspection GoUnusedParameter
-func assertI2I(inter *rt.GoType, i rt.GoIface) rt.GoIface
-
 //go:linkname mapiternext runtime.mapiternext
 //goland:noinspection GoUnusedParameter
 func mapiternext(it *rt.GoMapIterator)

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

@@ -38,10 +38,6 @@ func memmove(to unsafe.Pointer, from unsafe.Pointer, n uintptr)
 //goland:noinspection GoUnusedParameter
 func growslice(et *rt.GoType, old rt.GoSlice, cap int) rt.GoSlice
 
-//go:linkname assertI2I runtime.assertI2I2
-//goland:noinspection GoUnusedParameter
-func assertI2I(inter *rt.GoType, i rt.GoIface) rt.GoIface
-
 //go:linkname mapiternext runtime.mapiternext
 //goland:noinspection GoUnusedParameter
 func mapiternext(it *rt.GoMapIterator)

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

@@ -72,18 +72,6 @@ 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,11 +24,6 @@ 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")
@@ -42,7 +37,7 @@ func Type(t reflect.Type) obj.Addr {
 }
 
 func Itab(i *rt.GoType, t reflect.Type) obj.Addr {
-    return Imm(int64(uintptr(unsafe.Pointer(getitab(i, rt.UnpackType(t), false)))))
+    return Imm(int64(uintptr(unsafe.Pointer(rt.Getitab(rt.IfaceType(i), rt.UnpackType(t), false)))))
 }
 
 func Gitab(i *rt.GoItab) obj.Addr {

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

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

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

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

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

@@ -66,15 +66,16 @@ 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)

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

@@ -211,3 +211,24 @@ 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

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

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