[chore]: Bump github.com/gin-contrib/gzip from 1.0.0 to 1.0.1 (#2899)

Bumps [github.com/gin-contrib/gzip](https://github.com/gin-contrib/gzip) from 1.0.0 to 1.0.1.
- [Release notes](https://github.com/gin-contrib/gzip/releases)
- [Changelog](https://github.com/gin-contrib/gzip/blob/master/.goreleaser.yaml)
- [Commits](https://github.com/gin-contrib/gzip/compare/v1.0.0...v1.0.1)

---
updated-dependencies:
- dependency-name: github.com/gin-contrib/gzip
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

1 files changed, 197 insertions, 0 deletions

diff --git a/vendor/github.com/bytedance/sonic/loader/internal/abi/abi.go b/vendor/github.com/bytedance/sonic/loader/internal/abi/abi.go
new file mode 100644
index 000000000..524ab5330
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/loader/internal/abi/abi.go
@@ -0,0 +1,197 @@
+/*
+ * Copyright 2022 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package abi
+
+import (
+    `fmt`
+    `reflect`
+    `sort`
+    `strings`
+
+    `github.com/bytedance/sonic/loader/internal/rt`
+)
+
+type FunctionLayout struct {
+    FP   uint32
+    Args []Parameter
+    Rets []Parameter
+}
+
+func (self FunctionLayout) String() string {
+    return self.formatFn()
+}
+
+func (self FunctionLayout) ArgSize() uint32 {
+    size := uintptr(0) 
+    for _, arg := range self.Args {
+        size += arg.Type.Size()
+    }
+    return uint32(size)
+}
+
+type slot struct {
+    p bool
+    m uint32
+}
+
+func (self FunctionLayout) StackMap() *rt.StackMap {
+    var st []slot
+    var mb rt.StackMapBuilder
+
+    /* add arguments */
+    for _, v := range self.Args {
+        st = append(st, slot {
+            m: v.Mem,
+            p: v.IsPointer,
+        })
+    }
+
+    /* add stack-passed return values */
+    for _, v := range self.Rets {
+        if !v.InRegister {
+            st = append(st, slot {
+                m: v.Mem,
+                p: v.IsPointer,
+            })
+        }
+    }
+
+    /* sort by memory offset */
+    sort.Slice(st, func(i int, j int) bool {
+        return st[i].m < st[j].m
+    })
+
+    /* add the bits */
+    for _, v := range st {
+        mb.AddField(v.p)
+    }
+
+    /* build the stack map */
+    return mb.Build()
+}
+
+func (self FunctionLayout) formatFn() string {
+    fp := self.FP
+    return fmt.Sprintf("\n%#04x\nRets:\n%s\nArgs:\n%s", fp, self.formatSeq(self.Rets, &fp), self.formatSeq(self.Args, &fp))
+}
+
+func (self FunctionLayout) formatSeq(v []Parameter, fp *uint32) string {
+    nb := len(v)
+    mm := make([]string, 0, len(v))
+
+    /* convert each part */
+    for i := nb-1; i >=0; i-- {
+        *fp -= PtrSize
+        mm = append(mm, fmt.Sprintf("%#04x %s", *fp, v[i].String()))
+    }
+
+    /* join them together */
+    return strings.Join(mm, "\n")
+}
+
+type Frame struct {
+    desc      *FunctionLayout
+    locals    []bool
+    ccall     bool
+}
+
+func NewFrame(desc *FunctionLayout, locals []bool, ccall bool) Frame {
+    fr := Frame{}
+    fr.desc = desc
+    fr.locals = locals
+    fr.ccall = ccall
+    return fr
+}
+
+func (self *Frame) String() string {
+    out := self.desc.String()
+
+    off := -8
+    out += fmt.Sprintf("\n%#4x [Return PC]", off)
+    off -= 8
+    out += fmt.Sprintf("\n%#4x [RBP]", off)
+    off -= 8
+
+    for _, v := range ReservedRegs(self.ccall) {
+        out += fmt.Sprintf("\n%#4x [%v]", off, v)
+        off -= PtrSize
+    }
+
+    for _, b := range self.locals {
+        out += fmt.Sprintf("\n%#4x [%v]", off, b)
+        off -= PtrSize
+    }
+
+    return out
+}
+
+func (self *Frame) Prev() uint32 {
+    return self.Size() + PtrSize
+}
+
+func (self *Frame) Size() uint32 {
+    return uint32(self.Offs() + PtrSize)
+}
+
+func (self *Frame) Offs() uint32 {
+    return uint32(len(ReservedRegs(self.ccall)) * PtrSize + len(self.locals)*PtrSize)
+}
+
+func (self *Frame) ArgPtrs() *rt.StackMap {
+    return self.desc.StackMap()
+}
+
+func (self *Frame) LocalPtrs() *rt.StackMap {
+    var m rt.StackMapBuilder
+    for _, b := range self.locals {
+        m.AddFields(len(ReservedRegs(self.ccall)), b)
+    }
+    return m.Build()
+}
+
+func alignUp(n uint32, a int) uint32 {
+    return (uint32(n) + uint32(a) - 1) &^ (uint32(a) - 1)
+}
+
+func isPointer(vt reflect.Type) bool {
+    switch vt.Kind() {
+        case reflect.Bool          : fallthrough
+        case reflect.Int           : fallthrough
+        case reflect.Int8          : fallthrough
+        case reflect.Int16         : fallthrough
+        case reflect.Int32         : fallthrough
+        case reflect.Int64         : fallthrough
+        case reflect.Uint          : fallthrough
+        case reflect.Uint8         : fallthrough
+        case reflect.Uint16        : fallthrough
+        case reflect.Uint32        : fallthrough
+        case reflect.Uint64        : fallthrough
+        case reflect.Float32       : fallthrough
+        case reflect.Float64       : fallthrough
+        case reflect.Uintptr       : return false
+        case reflect.Chan          : fallthrough
+        case reflect.Func          : fallthrough
+        case reflect.Map           : fallthrough
+        case reflect.Ptr           : fallthrough
+        case reflect.UnsafePointer : return true
+        case reflect.Complex64     : fallthrough
+        case reflect.Complex128    : fallthrough
+        case reflect.Array         : fallthrough
+        case reflect.Struct        : panic("abi: unsupported types")
+        default                    : panic("abi: invalid value type")
+    }
+}
\ No newline at end of file