mirror of
https://github.com/superseriousbusiness/gotosocial.git
synced 2024-12-05 01:52:46 +00:00
a5f28fe0c9
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>
186 lines
4.8 KiB
Go
186 lines
4.8 KiB
Go
/**
|
|
* Copyright 2023 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 loader
|
|
|
|
import (
|
|
`reflect`
|
|
`unsafe`
|
|
|
|
`github.com/bytedance/sonic/loader/internal/abi`
|
|
`github.com/bytedance/sonic/loader/internal/rt`
|
|
)
|
|
|
|
var _C_Redzone = []bool{false, false, false, false}
|
|
|
|
// CFunc is a function information for C func
|
|
type CFunc struct {
|
|
// C function name
|
|
Name string
|
|
|
|
// entry pc relative to entire text segment
|
|
EntryOff uint32
|
|
|
|
// function text size in bytes
|
|
TextSize uint32
|
|
|
|
// maximum stack depth of the function
|
|
MaxStack uintptr
|
|
|
|
// PC->SP delta lists of the function
|
|
Pcsp [][2]uint32
|
|
}
|
|
|
|
// GoC is the wrapper for Go calls to C
|
|
type GoC struct {
|
|
// CName is the name of corresponding C function
|
|
CName string
|
|
|
|
// CEntry points out where to store the entry address of corresponding C function.
|
|
// It won't be set if nil
|
|
CEntry *uintptr
|
|
|
|
// GoFunc is the POINTER of corresponding go stub function.
|
|
// It is used to generate Go-C ABI conversion wrapper and receive the wrapper's address
|
|
// eg. &func(a int, b int) int
|
|
// FOR
|
|
// int add(int a, int b)
|
|
// It won't be set if nil
|
|
GoFunc interface{}
|
|
}
|
|
|
|
// WrapGoC wraps C functions and loader it into Go stubs
|
|
func WrapGoC(text []byte, natives []CFunc, stubs []GoC, modulename string, filename string) {
|
|
funcs := make([]Func, len(natives))
|
|
|
|
// register C funcs
|
|
for i, f := range natives {
|
|
fn := Func{
|
|
Flag: FuncFlag_ASM,
|
|
EntryOff: f.EntryOff,
|
|
TextSize: f.TextSize,
|
|
Name: f.Name,
|
|
}
|
|
if len(f.Pcsp) != 0 {
|
|
fn.Pcsp = (*Pcdata)(unsafe.Pointer(&natives[i].Pcsp))
|
|
}
|
|
// NOTICE: always forbid async preempt
|
|
fn.PcUnsafePoint = &Pcdata{
|
|
{PC: f.TextSize, Val: PCDATA_UnsafePointUnsafe},
|
|
}
|
|
// NOTICE: always refer to first file
|
|
fn.Pcfile = &Pcdata{
|
|
{PC: f.TextSize, Val: 0},
|
|
}
|
|
// NOTICE: always refer to first line
|
|
fn.Pcline = &Pcdata{
|
|
{PC: f.TextSize, Val: 1},
|
|
}
|
|
// NOTICE: copystack need locals stackmap
|
|
fn.PcStackMapIndex = &Pcdata{
|
|
{PC: f.TextSize, Val: 0},
|
|
}
|
|
sm := rt.StackMapBuilder{}
|
|
sm.AddField(false)
|
|
fn.ArgsPointerMaps = sm.Build()
|
|
fn.LocalsPointerMaps = sm.Build()
|
|
funcs[i] = fn
|
|
}
|
|
rets := Load(text, funcs, modulename, []string{filename})
|
|
|
|
// got absolute entry address
|
|
native_entry := **(**uintptr)(unsafe.Pointer(&rets[0]))
|
|
// println("native_entry: ", native_entry)
|
|
|
|
wraps := make([]Func, 0, len(stubs))
|
|
wrapIds := make([]int, 0, len(stubs))
|
|
code := make([]byte, 0, len(wraps))
|
|
entryOff := uint32(0)
|
|
|
|
// register go wrappers
|
|
for i := range stubs {
|
|
for j := range natives {
|
|
if stubs[i].CName != natives[j].Name {
|
|
continue
|
|
}
|
|
|
|
// calculate corresponding C entry
|
|
pc := uintptr(native_entry + uintptr(natives[j].EntryOff))
|
|
if stubs[i].CEntry != nil {
|
|
*stubs[i].CEntry = pc
|
|
}
|
|
|
|
// no need to generate wrapper, continue next
|
|
if stubs[i].GoFunc == nil {
|
|
continue
|
|
}
|
|
|
|
// assemble wrapper codes
|
|
layout := abi.NewFunctionLayout(reflect.TypeOf(stubs[i].GoFunc).Elem())
|
|
frame := abi.NewFrame(&layout, _C_Redzone, true)
|
|
tcode := abi.CallC(pc, frame, natives[j].MaxStack)
|
|
code = append(code, tcode...)
|
|
size := uint32(len(tcode))
|
|
|
|
fn := Func{
|
|
Flag: FuncFlag_ASM,
|
|
ArgsSize: int32(layout.ArgSize()),
|
|
EntryOff: entryOff,
|
|
TextSize: size,
|
|
Name: stubs[i].CName + "_go",
|
|
}
|
|
|
|
// add check-stack and grow-stack texts' pcsp
|
|
fn.Pcsp = &Pcdata{
|
|
{PC: uint32(frame.StackCheckTextSize()), Val: 0},
|
|
{PC: size - uint32(frame.GrowStackTextSize()), Val: int32(frame.Size())},
|
|
{PC: size, Val: 0},
|
|
}
|
|
// NOTICE: always refer to first file
|
|
fn.Pcfile = &Pcdata{
|
|
{PC: size, Val: 0},
|
|
}
|
|
// NOTICE: always refer to first line
|
|
fn.Pcline = &Pcdata{
|
|
{PC: size, Val: 1},
|
|
}
|
|
// NOTICE: always forbid async preempt
|
|
fn.PcUnsafePoint = &Pcdata{
|
|
{PC: size, Val: PCDATA_UnsafePointUnsafe},
|
|
}
|
|
|
|
// register pointer stackmaps
|
|
fn.PcStackMapIndex = &Pcdata{
|
|
{PC: size, Val: 0},
|
|
}
|
|
fn.ArgsPointerMaps = frame.ArgPtrs()
|
|
fn.LocalsPointerMaps = frame.LocalPtrs()
|
|
|
|
entryOff += size
|
|
wraps = append(wraps, fn)
|
|
wrapIds = append(wrapIds, i)
|
|
}
|
|
}
|
|
gofuncs := Load(code, wraps, modulename+"/go", []string{filename+".go"})
|
|
|
|
// set go func value
|
|
for i := range gofuncs {
|
|
idx := wrapIds[i]
|
|
w := rt.UnpackEface(stubs[idx].GoFunc)
|
|
*(*Function)(w.Value) = gofuncs[i]
|
|
}
|
|
}
|