处理AI胡乱生成的乱摊子

.gitignore

@@ -1,7 +1,3 @@
-# ---> Go
-# If you prefer the allow list template instead of the deny list, see community template:
-# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
-#
 # Binaries for programs and plugins
 *.exe
 *.exe~
@@ -9,21 +5,19 @@
 *.so
 *.dylib
 
-# Test binary, built with `go test -c`
+# Test binary, built with go test -c
 *.test
 
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
 
-# Dependency directories (remove the comment below to include it)
-# vendor/
+# Dependency directories
+vendor/
 
-# Go workspace file
-go.work
-go.work.sum
+# IDE-specific files
+.idea/
+*.swp
+*.swo
 
-# env file
+# Environment files
 .env
-
-.idea
-.vscode

Makefile

@@ -0,0 +1,27 @@
+# Makefile for pig-farm-controller
+
+# 默认目标
+.PHONY: help
+help:
+	@echo "Usage: make [target]"
+	@echo
+	@echo "Targets:"
+	@echo "  run          Run the application"
+	@echo "  build        Build the application"
+	@echo "  clean        Clean generated files"
+	@echo "  help         Show this help message"
+
+# 运行应用
+.PHONY: run
+run:
+	go run main.go
+
+# 构建应用
+.PHONY: build
+build:
+	go build -o bin/pig-farm-controller .
+
+# 清理生成文件
+.PHONY: clean
+clean:
+	rm -f bin/pig-farm-controller

go.mod

@@ -10,35 +10,37 @@ require (
 )
 
 require (
-	github.com/bytedance/sonic v1.9.1 // indirect
-	github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 // indirect
+	github.com/bytedance/sonic v1.10.0 // indirect
+	github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d // indirect
+	github.com/chenzhuoyu/iasm v0.9.0 // indirect
 	github.com/gabriel-vasile/mimetype v1.4.2 // indirect
 	github.com/gin-contrib/sse v0.1.0 // indirect
 	github.com/go-playground/locales v0.14.1 // indirect
 	github.com/go-playground/universal-translator v0.18.1 // indirect
 	github.com/go-playground/validator/v10 v10.14.0 // indirect
 	github.com/goccy/go-json v0.10.2 // indirect
+	github.com/google/go-cmp v0.6.0 // indirect
 	github.com/jackc/pgpassfile v1.0.0 // indirect
 	github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
 	github.com/jackc/pgx/v5 v5.4.3 // indirect
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.5 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
-	github.com/klauspost/cpuid/v2 v2.2.4 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.5 // indirect
 	github.com/kr/text v0.2.0 // indirect
 	github.com/leodido/go-urn v1.2.4 // indirect
 	github.com/mattn/go-isatty v0.0.19 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
-	github.com/pelletier/go-toml/v2 v2.0.8 // indirect
+	github.com/pelletier/go-toml/v2 v2.0.9 // indirect
 	github.com/rogpeppe/go-internal v1.14.1 // indirect
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 	github.com/ugorji/go/codec v1.2.11 // indirect
-	golang.org/x/arch v0.3.0 // indirect
-	golang.org/x/crypto v0.14.0 // indirect
-	golang.org/x/net v0.10.0 // indirect
+	golang.org/x/arch v0.4.0 // indirect
+	golang.org/x/crypto v0.28.0 // indirect
+	golang.org/x/net v0.30.0 // indirect
 	golang.org/x/sys v0.26.0 // indirect
-	golang.org/x/text v0.13.0 // indirect
-	google.golang.org/protobuf v1.30.0 // indirect
+	golang.org/x/text v0.19.0 // indirect
+	google.golang.org/protobuf v1.31.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,9 +1,13 @@
 github.com/bytedance/sonic v1.5.0/go.mod h1:ED5hyg4y6t3/9Ku1R6dU/4KyJ48DZ4jPhfY1O2AihPM=
-github.com/bytedance/sonic v1.9.1 h1:6iJ6NqdoxCDr6mbY8h18oSO+cShGSMRGCEo7F2h0x8s=
-github.com/bytedance/sonic v1.9.1/go.mod h1:i736AoUSYt75HyZLoJW9ERYxcy6eaN6h4BZXU064P/U=
+github.com/bytedance/sonic v1.10.0-rc/go.mod h1:ElCzW+ufi8qKqNW0FY314xriJhyJhuoJ3gFZdAHF7NM=
+github.com/bytedance/sonic v1.10.0 h1:qtNZduETEIWJVIyDl01BeNxur2rW9OwTQ/yBqFRkKEk=
+github.com/bytedance/sonic v1.10.0/go.mod h1:iZcSUejdk5aukTND/Eu/ivjQuEL0Cu9/rf50Hi0u/g4=
 github.com/chenzhuoyu/base64x v0.0.0-20211019084208-fb5309c8db06/go.mod h1:DH46F32mSOjUmXrMHnKwZdA8wcEefY7UVqBKYGjpdQY=
-github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 h1:qSGYFH7+jGhDF8vLC+iwCD4WpbV1EBDSzWkJODFLams=
 github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311/go.mod h1:b583jCggY9gE99b6G5LEC39OIiVsWj+R97kbl5odCEk=
+github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d h1:77cEq6EriyTZ0g/qfRdp61a3Uu/AWrgIq2s0ClJV1g0=
+github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d/go.mod h1:8EPpVsBuRksnlj1mLy4AWzRNQYxauNi62uWcE3to6eA=
+github.com/chenzhuoyu/iasm v0.9.0 h1:9fhXjVzq5hUy2gkhhgHl95zG2cEAhw9OSGs8toWWAwo=
+github.com/chenzhuoyu/iasm v0.9.0/go.mod h1:Xjy2NpN3h7aUqeqM+woSuuvxmIe6+DDsiNLIrkAmYog=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
@@ -25,8 +29,9 @@ github.com/go-playground/validator/v10 v10.14.0/go.mod h1:9iXMNT7sEkjXb0I+enO7QX
 github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
 github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
 github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
-github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
 github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
@@ -41,8 +46,9 @@ github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
 github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
-github.com/klauspost/cpuid/v2 v2.2.4 h1:acbojRNwl3o09bUq+yDCtZFc1aiwaAAxtcn8YkZXnvk=
-github.com/klauspost/cpuid/v2 v2.2.4/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY=
+github.com/klauspost/cpuid/v2 v2.2.5 h1:0E5MSMDEoAulmXNFquVs//DdoomxaoTY1kUhbc/qbZg=
+github.com/klauspost/cpuid/v2 v2.2.5/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
+github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M=
 github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
 github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
@@ -56,8 +62,8 @@ github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
-github.com/pelletier/go-toml/v2 v2.0.8 h1:0ctb6s9mE31h0/lhu+J6OPmVeDxJn+kYnJc2jZR9tGQ=
-github.com/pelletier/go-toml/v2 v2.0.8/go.mod h1:vuYfssBdrU2XDZ9bYydBu6t+6a6PYNcZljzZR9VXg+4=
+github.com/pelletier/go-toml/v2 v2.0.9 h1:uH2qQXheeefCCkuBBSLi7jCiSmj3VRh2+Goq2N7Xxu0=
+github.com/pelletier/go-toml/v2 v2.0.9/go.mod h1:tJU2Z3ZkXwnxa4DPO899bsyIoywizdUvyaeZurnPPDc=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
@@ -71,30 +77,29 @@ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/stretchr/testify v1.8.3 h1:RP3t2pwF7cMEbC1dqtB6poj3niw/9gnV4Cjg5oW5gtY=
-github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
 github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
 github.com/ugorji/go/codec v1.2.11 h1:BMaWp1Bb6fHwEtbplGBGJ498wD+LKlNSl25MjdZY4dU=
 github.com/ugorji/go/codec v1.2.11/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
 golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
-golang.org/x/arch v0.3.0 h1:02VY4/ZcO/gBOH6PUaoiptASxtXU10jazRCP865E97k=
-golang.org/x/arch v0.3.0/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
-golang.org/x/crypto v0.14.0 h1:wBqGXzWJW6m1XrIKlAH0Hs1JJ7+9KBwnIO8v66Q9cHc=
-golang.org/x/crypto v0.14.0/go.mod h1:MVFd36DqK4CsrnJYDkBA3VC4m2GkXAM0PvzMCn4JQf4=
-golang.org/x/net v0.10.0 h1:X2//UzNDwYmtCLn7To6G58Wr6f5ahEAQgKNzv9Y951M=
-golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
-golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/arch v0.4.0 h1:A8WCeEWhLwPBKNbFi5Wv5UTCBx5zzubnXDlMOFAzFMc=
+golang.org/x/arch v0.4.0/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
+golang.org/x/crypto v0.28.0 h1:GBDwsMXVQi34v5CCYUm2jkJvu4cbtru2U4TN2PSyQnw=
+golang.org/x/crypto v0.28.0/go.mod h1:rmgy+3RHxRZMyY0jjAJShp2zgEdOqj2AO7U0pYmeQ7U=
+golang.org/x/net v0.30.0 h1:AcW1SDZMkb8IpzCdQUaIq2sP4sZ4zw+55h6ynffypl4=
+golang.org/x/net v0.30.0/go.mod h1:2wGyMJ5iFasEhkwi13ChkO/t1ECNC4X4eBKkVFyYFlU=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.26.0 h1:KHjCJyddX0LoSTb3J+vWpupP9p0oznkqVk/IfjymZbo=
 golang.org/x/sys v0.26.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k=
-golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/text v0.19.0 h1:kTxAhCbGbxhK0IwgSKiMO5awPoDQ0RpfiVYBfK860YM=
+golang.org/x/text v0.19.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
-google.golang.org/protobuf v1.30.0 h1:kPPoIgf3TsEvrm0PFe15JQ+570QVxYzEvvHqChK+cng=
-google.golang.org/protobuf v1.30.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=
+google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
@@ -107,4 +112,5 @@ gorm.io/driver/postgres v1.5.7 h1:8ptbNJTDbEmhdr62uReG5BGkdQyeasu/FZHxI0IMGnM=
 gorm.io/driver/postgres v1.5.7/go.mod h1:3e019WlBaYI5o5LIdNV+LyxCMNtLOQETBXL2h4chKpA=
 gorm.io/gorm v1.25.7 h1:VsD6acwRjz2zFxGO50gPO6AkNs7KKnvfzUjHQhZDz/A=
 gorm.io/gorm v1.25.7/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8=
+nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50=
 rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=

internal/api/api.go

@@ -117,6 +117,13 @@ func (a *API) setupRoutes() {
 }
 
 // healthHandler 健康检查处理函数
+// @Summary 健康检查
+// @Description 检查API服务是否正常运行
+// @Tags health
+// @Accept json
+// @Produce json
+// @Success 200 {object} map[string]interface{}
+// @Router /health [get]
 func (a *API) healthHandler(c *gin.Context) {
 	c.JSON(http.StatusOK, gin.H{
 		"status":  "ok",

internal/core/application.go

@@ -27,6 +27,9 @@ type Application struct {
 
 	// Config 应用配置
 	Config *config.Config
+
+	// logger 日志组件实例
+	logger *logs.Logger
 }
 
 // NewApplication 创建并返回一个新的核心应用实例
@@ -50,12 +53,11 @@ func NewApplication(cfg *config.Config) *Application {
 	taskExecutor := task.NewExecutor(5)
 
 	return &Application{
-		Storage:      store,
 		Storage:      store,
 		API:          apiInstance,
 		TaskExecutor: taskExecutor,
 		Config:       cfg,
-		logger:       logger,
+		logger:       logs.NewLogger(),
 	}
 }
 

internal/task/task.go

@@ -194,7 +194,7 @@ func (e *Executor) SubmitTask(task Task) {
 func (e *Executor) worker(id int) {
 	defer e.wg.Done()
 
-	e.logger.Info(fmt.Sprintf("Worker %d started", id))
+	e.logger.Info(fmt.Sprintf("Worker (id = %d) started", id))
 
 	for {
 		select {

main.go

@@ -1,5 +1,10 @@
 // Package main 是猪场控制系统的入口点
 // 负责初始化核心应用并管理其生命周期
+// @title 猪场管理系统API
+// @version 1.0
+// @description 猪场管理系统API文档
+// @host localhost:8086
+// @BasePath /
 package main
 
 import (

vendor/github.com/bytedance/sonic/Makefile

@@ -23,12 +23,12 @@ CPU_avx			:= amd64
 CPU_avx2		:= amd64
 CPU_sse  		:= amd64
 
-TMPL_avx		:= fastint_amd64_test fastfloat_amd64_test native_amd64_test native_export_amd64
-TMPL_avx2		:= fastint_amd64_test fastfloat_amd64_test native_amd64_test native_export_amd64
-TMPL_sse 		:= fastint_amd64_test fastfloat_amd64_test native_amd64_test native_export_amd64
+TMPL_avx		:= fastint_amd64_test fastfloat_amd64_test native_amd64_test recover_amd64_test
+TMPL_avx2		:= fastint_amd64_test fastfloat_amd64_test native_amd64_test recover_amd64_test
+TMPL_sse 		:= fastint_amd64_test fastfloat_amd64_test native_amd64_test recover_amd64_test
 
-CFLAGS_avx		:= -msse -mno-sse4 -mavx -mpclmul -mno-avx2 -DUSE_AVX=1 -DUSE_AVX2=0
-CFLAGS_avx2		:= -msse -mno-sse4 -mavx -mpclmul -mavx2    -DUSE_AVX=1 -DUSE_AVX2=1 
+CFLAGS_avx		:= -msse -mno-sse4 -mavx -mpclmul -mno-avx2 -mstack-alignment=0 -DUSE_AVX=1 -DUSE_AVX2=0
+CFLAGS_avx2		:= -msse -mno-sse4 -mavx -mpclmul -mavx2 -mstack-alignment=0 -DUSE_AVX=1 -DUSE_AVX2=1 
 CFLAGS_sse		:= -msse -mno-sse4 -mno-avx -mno-avx2 -mpclmul
 
 CC_amd64		:= clang
@@ -66,7 +66,7 @@ define build_arch
 	$(eval @cpu		:= $(value CPU_$(1)))
 	$(eval @deps	:= $(foreach tmpl,$(value TMPL_$(1)),${OUT_DIR}/$(1)/${tmpl}.go))
 	$(eval @asmin	:= ${TMP_DIR}/$(1)/native.s)
-	$(eval @asmout	:= ${OUT_DIR}/$(1)/native_${@cpu}.s)
+	$(eval @asmout	:= ${OUT_DIR}/$(1)/native_text_${@cpu}.go)
 	$(eval @stubin	:= ${OUT_DIR}/native_${@cpu}.tmpl)
 	$(eval @stubout	:= ${OUT_DIR}/$(1)/native_${@cpu}.go)
 
@@ -75,8 +75,7 @@ $(1): ${@asmout} ${@deps}
 ${@asmout}: ${@stubout} ${NATIVE_SRC}
 	mkdir -p ${TMP_DIR}/$(1)
 	$${CC_${@cpu}} $${CFLAGS} $${CFLAGS_$(1)} -S -o ${TMP_DIR}/$(1)/native.s ${SRC_FILE}
-	python3 $${ASM2ASM_${@cpu}} ${@asmout} ${TMP_DIR}/$(1)/native.s
-	asmfmt -w ${@asmout}
+	python3 $${ASM2ASM_${@cpu}} -r ${@stubout} ${TMP_DIR}/$(1)/native.s
 
 $(eval $(call 	\
 	build_tmpl,	\

vendor/github.com/bytedance/sonic/README.md

@@ -5,8 +5,8 @@ English | [中文](README_ZH_CN.md)
 A blazingly fast JSON serializing & deserializing library, accelerated by JIT (just-in-time compiling) and SIMD (single-instruction-multiple-data).
 
 ## Requirement
-- Go 1.15~1.20
-- Linux/MacOS/Windows
+- Go 1.16~1.21
+- Linux / MacOS / Windows(need go1.17 above)
 - Amd64 ARCH
 
 ## Features
@@ -76,6 +76,10 @@ BenchmarkSetOne_Jsoniter-16                            79475 ns/op         163.8
 BenchmarkSetOne_Parallel_Sonic-16                      850.9 ns/op       15305.31 MB/s        1584 B/op         17 allocs/op
 BenchmarkSetOne_Parallel_Sjson-16                      18194 ns/op         715.77 MB/s       52247 B/op          9 allocs/op
 BenchmarkSetOne_Parallel_Jsoniter-16                   33560 ns/op         388.05 MB/s       45892 B/op        964 allocs/op
+BenchmarkLoadNode/LoadAll()-16                         11384 ns/op        1143.93 MB/s        6307 B/op         25 allocs/op
+BenchmarkLoadNode_Parallel/LoadAll()-16                 5493 ns/op        2370.68 MB/s        7145 B/op         25 allocs/op
+BenchmarkLoadNode/Interface()-16                       17722 ns/op         734.85 MB/s       13323 B/op         88 allocs/op
+BenchmarkLoadNode_Parallel/Interface()-16              10330 ns/op        1260.70 MB/s       15178 B/op         88 allocs/op
 ```
 - [Small](https://github.com/bytedance/sonic/blob/main/testdata/small.go) (400B, 11 keys, 3 layers)
 ![small benchmarks](./docs/imgs/bench-small.png)
@@ -282,6 +286,42 @@ println(string(buf) == string(exp)) // true
 - iteration: `Values()`, `Properties()`, `ForEach()`, `SortKeys()`
 - modification: `Set()`, `SetByIndex()`, `Add()`
 
+### Ast.Visitor
+Sonic provides an advanced API for fully parsing JSON into non-standard types (neither `struct` not `map[string]interface{}`) without using any intermediate representation (`ast.Node` or `interface{}`). For example, you might have the following types which are like `interface{}` but actually not `interface{}`:
+```go
+type UserNode interface {}
+
+// the following types implement the UserNode interface.
+type (
+    UserNull    struct{}
+    UserBool    struct{ Value bool }
+    UserInt64   struct{ Value int64 }
+    UserFloat64 struct{ Value float64 }
+    UserString  struct{ Value string }
+    UserObject  struct{ Value map[string]UserNode }
+    UserArray   struct{ Value []UserNode }
+)
+```
+Sonic provides the following API to return **the preorder traversal of a JSON AST**. The `ast.Visitor` is a SAX style interface which is used in some C++ JSON library. You should implement `ast.Visitor` by yourself and pass it to `ast.Preorder()` method. In your visitor you can make your custom types to represent JSON values. There may be an O(n) space container (such as stack) in your visitor to record the object / array hierarchy.
+```go
+func Preorder(str string, visitor Visitor, opts *VisitorOptions) error
+
+type Visitor interface {
+    OnNull() error
+    OnBool(v bool) error
+    OnString(v string) error
+    OnInt64(v int64, n json.Number) error
+    OnFloat64(v float64, n json.Number) error
+    OnObjectBegin(capacity int) error
+    OnObjectKey(key string) error
+    OnObjectEnd() error
+    OnArrayBegin(capacity int) error
+    OnArrayEnd() error
+}
+```
+
+See [ast/visitor.go](https://github.com/bytedance/sonic/blob/main/ast/visitor.go) for detailed usage. We also implement a demo visitor for `UserNode` in [ast/visitor_test.go](https://github.com/bytedance/sonic/blob/main/ast/visitor_test.go).
+
 ## Compatibility
 Sonic **DOES NOT** ensure to support all environments, due to the difficulty of developing high-performance codes. For developers who use sonic to build their applications in different environments, we have the following suggestions:
 
@@ -358,5 +398,14 @@ Why? Because `ast.Node` stores its children using `array`:
 
 **CAUTION:** `ast.Node` **DOESN'T** ensure concurrent security directly, due to its **lazy-load** design. However, you can call `Node.Load()`/`Node.LoadAll()` to achieve that, which may bring performance reduction while it still works faster than converting to `map` or `interface{}`
 
+### Ast.Node or Ast.Visitor?
+For generic data, `ast.Node` should be enough for your needs in most cases.
+
+However, `ast.Node` is designed for partially processing JSON string. It has some special designs such as lazy-load which might not be suitable for directly parsing the whole JSON string like `Unmarshal()`. Although `ast.Node` is better then `map` or `interface{}`, it's also a kind of intermediate representation after all if your final types are customized and you have to convert the above types to your custom types after parsing.
+
+For better performance, in previous case the `ast.Visitor` will be the better choice. It performs JSON decoding like `Unmarshal()` and you can directly use your final types to represents a JSON AST without any intermediate representations.
+
+But `ast.Visitor` is not a very handy API. You might need to write a lot of code to implement your visitor and carefully maintain the tree hierarchy during decoding. Please read the comments in [ast/visitor.go](https://github.com/bytedance/sonic/blob/main/ast/visitor.go) carefully if you decide to use this API.
+
 ## Community
 Sonic is a subproject of [CloudWeGo](https://www.cloudwego.io/). We are committed to building a cloud native ecosystem.

vendor/github.com/bytedance/sonic/README_ZH_CN.md

@@ -6,8 +6,8 @@
 
 ## 依赖
 
-- Go 1.15~1.20
-- Linux/MacOS/Windows
+- Go 1.16~1.20
+- Linux / MacOS / Windows（需要 Go1.17 以上）
 - Amd64 架构
 
 ## 特色
@@ -79,6 +79,10 @@ BenchmarkSetOne_Jsoniter-16                            79475 ns/op         163.8
 BenchmarkSetOne_Parallel_Sonic-16                      850.9 ns/op       15305.31 MB/s        1584 B/op         17 allocs/op
 BenchmarkSetOne_Parallel_Sjson-16                      18194 ns/op         715.77 MB/s       52247 B/op          9 allocs/op
 BenchmarkSetOne_Parallel_Jsoniter-16                   33560 ns/op         388.05 MB/s       45892 B/op        964 allocs/op
+BenchmarkLoadNode/LoadAll()-16                         11384 ns/op        1143.93 MB/s        6307 B/op         25 allocs/op
+BenchmarkLoadNode_Parallel/LoadAll()-16                 5493 ns/op        2370.68 MB/s        7145 B/op         25 allocs/op
+BenchmarkLoadNode/Interface()-16                       17722 ns/op         734.85 MB/s       13323 B/op         88 allocs/op
+BenchmarkLoadNode_Parallel/Interface()-16              10330 ns/op        1260.70 MB/s       15178 B/op         88 allocs/op
 ```
 - [小型](https://github.com/bytedance/sonic/blob/main/testdata/small.go) (400B, 11 个键, 3 层)
 ![small benchmarks](./docs/imgs/bench-small.png)
@@ -298,6 +302,41 @@ println(string(buf) == string(exp)) // true
 - 迭代： `Values()`, `Properties()`, `ForEach()`, `SortKeys()`
 - 修改： `Set()`, `SetByIndex()`, `Add()`
 
+### `Ast.Visitor`
+Sonic 提供了一个高级的 API 用于直接全量解析 JSON 到非标准容器里 (既不是 `struct` 也不是 `map[string]interface{}`) 且不需要借助任何中间表示 (`ast.Node` 或 `interface{}`)。举个例子，你可能定义了下述的类型，它们看起来像 `interface{}`，但实际上并不是：
+```go
+type UserNode interface {}
+
+// the following types implement the UserNode interface.
+type (
+    UserNull    struct{}
+    UserBool    struct{ Value bool }
+    UserInt64   struct{ Value int64 }
+    UserFloat64 struct{ Value float64 }
+    UserString  struct{ Value string }
+    UserObject  struct{ Value map[string]UserNode }
+    UserArray   struct{ Value []UserNode }
+)
+```
+Sonic 提供了下述的 API 来返回 **“对 JSON AST 的前序遍历”**。`ast.Visitor` 是一个 SAX 风格的接口，这在某些 C++ 的 JSON 解析库中被使用到。你需要自己实现一个 `ast.Visitor`，将它传递给 `ast.Preorder()` 方法。在你的实现中你可以使用自定义的类型来表示 JSON 的值。在你的 `ast.Visitor` 中，可能需要有一个 O(n) 空间复杂度的容器（比如说栈）来记录 object / array 的层级。
+```go
+func Preorder(str string, visitor Visitor, opts *VisitorOptions) error
+
+type Visitor interface {
+    OnNull() error
+    OnBool(v bool) error
+    OnString(v string) error
+    OnInt64(v int64, n json.Number) error
+    OnFloat64(v float64, n json.Number) error
+    OnObjectBegin(capacity int) error
+    OnObjectKey(key string) error
+    OnObjectEnd() error
+    OnArrayBegin(capacity int) error
+    OnArrayEnd() error
+}
+```
+详细用法参看 [ast/visitor.go](https://github.com/bytedance/sonic/blob/main/ast/visitor.go)，我们还为 `UserNode` 实现了一个示例 `ast.Visitor`，你可以在 [ast/visitor_test.go](https://github.com/bytedance/sonic/blob/main/ast/visitor_test.go) 中找到它。
+
 ## 兼容性
 由于开发高性能代码的困难性， Sonic **不**保证对所有环境的支持。对于在不同环境中使用 Sonic 构建应用程序的开发者，我们有以下建议：
 
@@ -377,6 +416,15 @@ go someFunc(user)
 
 **注意**：由于 `ast.Node` 的惰性加载设计，其**不能**直接保证并发安全性，但你可以调用 `Node.Load()` / `Node.LoadAll()` 来实现并发安全。尽管可能会带来性能损失，但仍比转换成 `map` 或 `interface{}` 更为高效。
 
+### 使用 `ast.Node` 还是 `ast.Visitor`？
+对于泛型数据的解析，`ast.Node` 在大多数场景上应该能够满足你的需求。
+
+然而，`ast.Node` 是一种针对部分解析 JSON 而设计的泛型容器，它包含一些特殊设计，比如惰性加载，如果你希望像 `Unmarshal()` 那样直接解析整个 JSON，这些设计可能并不合适。尽管 `ast.Node` 相较于 `map` 或 `interface{}` 来说是更好的一种泛型容器，但它毕竟也是一种中间表示，如果你的最终类型是自定义的，你还得在解析完成后将上述类型转化成你自定义的类型。
+
+在上述场景中，如果想要有更极致的性能，`ast.Visitor` 会是更好的选择。它采用和 `Unmarshal()` 类似的形式解析 JSON，并且你可以直接使用你的最终类型去表示 JSON AST，而不需要经过额外的任何中间表示。
+
+但是，`ast.Visitor` 并不是一个很易用的 API。你可能需要写大量的代码去实现自己的 `ast.Visitor`，并且需要在解析过程中仔细维护树的层级。如果你决定要使用这个 API，请先仔细阅读 [ast/visitor.go](https://github.com/bytedance/sonic/blob/main/ast/visitor.go) 中的注释。
+
 ## 社区
 
 Sonic 是 [CloudWeGo](https://www.cloudwego.io/) 下的一个子项目。我们致力于构建云原生生态系统。

vendor/github.com/bytedance/sonic/api.go

@@ -184,3 +184,8 @@ func Get(src []byte, path ...interface{}) (ast.Node, error) {
 func GetFromString(src string, path ...interface{}) (ast.Node, error) {
     return ast.NewSearcher(src).GetByPath(path...)
 }
+
+// Valid reports whether data is a valid JSON encoding.
+func Valid(data []byte) bool {
+    return ConfigDefault.Valid(data)
+}

vendor/github.com/bytedance/sonic/ast/api_amd64.go

@@ -1,4 +1,4 @@
-// +build amd64,go1.15,!go1.21
+// +build amd64,go1.16,!go1.22
 
 /*
  * Copyright 2022 ByteDance Inc.
@@ -87,7 +87,13 @@ func encodeBase64(src []byte) string {
 
 func (self *Parser) decodeValue() (val types.JsonState) {
     sv := (*rt.GoString)(unsafe.Pointer(&self.s))
-    self.p = native.Value(sv.Ptr, sv.Len, self.p, &val, 0)
+    flag := types.F_USE_NUMBER
+    if self.dbuf != nil {
+        flag = 0
+        val.Dbuf = self.dbuf
+        val.Dcap = types.MaxDigitNums
+    }
+    self.p = native.Value(sv.Ptr, sv.Len, self.p, &val, uint64(flag))
     return
 }
 

vendor/github.com/bytedance/sonic/ast/api_compat.go

@@ -1,4 +1,4 @@
-// +build !amd64 go1.21
+// +build !amd64 !go1.16 go1.22
 
 /*
  * Copyright 2022 ByteDance Inc.
@@ -27,6 +27,10 @@ import (
     `github.com/bytedance/sonic/internal/rt`
 )
 
+func init() {
+    println("WARNING: sonic only supports Go1.16~1.20 && CPU amd64, but your environment is not suitable")
+}
+
 func quote(buf *[]byte, val string) {
     quoteString(buf, val)
 }
@@ -49,7 +53,7 @@ func encodeBase64(src []byte) string {
 }
 
 func (self *Parser) decodeValue() (val types.JsonState) {
-    e, v := decodeValue(self.s, self.p)
+    e, v := decodeValue(self.s, self.p, self.dbuf == nil)
     if e < 0 {
         return v
     }

vendor/github.com/bytedance/sonic/ast/decode.go

@@ -220,7 +220,7 @@ func decodeFloat64(src string, pos int) (ret int, v float64, err error) {
     return ret, v, nil
 }
 
-func decodeValue(src string, pos int) (ret int, v types.JsonState) {
+func decodeValue(src string, pos int, skipnum bool) (ret int, v types.JsonState) {
     pos = skipBlank(src, pos)
     if pos < 0 {
         return pos, types.JsonState{Vt: types.ValueType(pos)}
@@ -256,20 +256,30 @@ func decodeValue(src string, pos int) (ret int, v types.JsonState) {
         }
         return ret, types.JsonState{Vt: types.V_FALSE}
     case '-', '+', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
-        var iv int64
-        ret, iv, _ = decodeInt64(src, pos)
-        if ret >= 0 {
-            return ret, types.JsonState{Vt: types.V_INTEGER, Iv: iv, Ep: pos}
-        } else if ret != -int(types.ERR_INVALID_NUMBER_FMT) {
-            return ret, types.JsonState{Vt: types.ValueType(ret)}
-        }
-        var fv float64
-        ret, fv, _ = decodeFloat64(src, pos)
-        if ret >= 0 {
-            return ret, types.JsonState{Vt: types.V_DOUBLE, Dv: fv, Ep: pos}
+        if skipnum {
+            ret = skipNumber(src, pos)
+            if ret >= 0 {
+                return ret, types.JsonState{Vt: types.V_DOUBLE, Iv: 0, Ep: pos}
+            } else {
+                return ret, types.JsonState{Vt: types.ValueType(ret)}
+            }
         } else {
-            return ret, types.JsonState{Vt: types.ValueType(ret)}
+            var iv int64
+            ret, iv, _ = decodeInt64(src, pos)
+            if ret >= 0 {
+                return ret, types.JsonState{Vt: types.V_INTEGER, Iv: iv, Ep: pos}
+            } else if ret != -int(types.ERR_INVALID_NUMBER_FMT) {
+                return ret, types.JsonState{Vt: types.ValueType(ret)}
+            }
+            var fv float64
+            ret, fv, _ = decodeFloat64(src, pos)
+            if ret >= 0 {
+                return ret, types.JsonState{Vt: types.V_DOUBLE, Dv: fv, Ep: pos}
+            } else {
+                return ret, types.JsonState{Vt: types.ValueType(ret)}
+            }
         }
+        
     default:
         return -int(types.ERR_INVALID_CHAR), types.JsonState{Vt:-types.ValueType(types.ERR_INVALID_CHAR)}
     }

vendor/github.com/bytedance/sonic/ast/encode.go

@@ -19,8 +19,6 @@ package ast
 import (
     `sync`
     `unicode/utf8`
-
-    `github.com/bytedance/sonic/internal/rt`
 )
 
 const (
@@ -165,18 +163,18 @@ func (self *Node) encodeFalse(buf *[]byte) error {
 }
 
 func (self *Node) encodeNumber(buf *[]byte) error {
-    str := rt.StrFrom(self.p, self.v)
+    str := self.toString()
     *buf = append(*buf, str...)
     return nil
 }
 
 func (self *Node) encodeString(buf *[]byte) error {
-    if self.v == 0 {
+    if self.l == 0 {
         *buf = append(*buf, '"', '"')
         return nil
     }
 
-    quote(buf, rt.StrFrom(self.p, self.v))
+    quote(buf, self.toString())
     return nil
 }
 
@@ -195,16 +193,28 @@ func (self *Node) encodeArray(buf *[]byte) error {
     
     *buf = append(*buf, '[')
 
-    var p = (*Node)(self.p)
-    err := p.encode(buf)
-    if err != nil {
-        return err
+    var s = (*linkedNodes)(self.p)
+    var started bool
+    if nb > 0 {
+        n := s.At(0)
+        if n.Exists() {
+            if err := n.encode(buf); err != nil {
+                return err
+            }
+            started = true
+        }
     }
+
     for i := 1; i < nb; i++ {
-        *buf = append(*buf, ',')
-        p = p.unsafe_next()
-        err := p.encode(buf)
-        if err != nil {
+        n := s.At(i)
+        if !n.Exists() {
+            continue
+        }
+        if started {
+            *buf = append(*buf, ',')
+        }
+        started = true
+        if err := n.encode(buf); err != nil {
             return err
         }
     }
@@ -240,16 +250,28 @@ func (self *Node) encodeObject(buf *[]byte) error {
     
     *buf = append(*buf, '{')
 
-    var p = (*Pair)(self.p)
-    err := p.encode(buf)
-    if err != nil {
-        return err
+    var s = (*linkedPairs)(self.p)
+    var started bool
+    if nb > 0 {
+        n := s.At(0)
+        if n.Value.Exists() {
+            if err := n.encode(buf); err != nil {
+                return err
+            }
+            started = true
+        }
     }
+
     for i := 1; i < nb; i++ {
-        *buf = append(*buf, ',')
-        p = p.unsafe_next()
-        err := p.encode(buf)
-        if err != nil {
+        n := s.At(i)
+        if !n.Value.Exists() {
+            continue
+        }
+        if started {
+            *buf = append(*buf, ',')
+        }
+        started = true
+        if err := n.encode(buf); err != nil {
             return err
         }
     }

vendor/github.com/bytedance/sonic/ast/error.go

@@ -8,6 +8,33 @@ import (
     `github.com/bytedance/sonic/internal/native/types`
 )
 
+
+func newError(err types.ParsingError, msg string) *Node {
+    return &Node{
+        t: V_ERROR,
+        l: uint(err),
+        p: unsafe.Pointer(&msg),
+    }
+}
+
+// Error returns error message if the node is invalid
+func (self Node) Error() string {
+    if self.t != V_ERROR {
+        return ""
+    } else {
+        return *(*string)(self.p)
+    } 
+}
+
+func newSyntaxError(err SyntaxError) *Node {
+    msg := err.Description()
+    return &Node{
+        t: V_ERROR,
+        l: uint(err.Code),
+        p: unsafe.Pointer(&msg),
+    }
+}
+
 func (self *Parser) syntaxError(err types.ParsingError) SyntaxError {
     return SyntaxError{
         Pos : self.p,
@@ -16,12 +43,17 @@ func (self *Parser) syntaxError(err types.ParsingError) SyntaxError {
     }
 }
 
-func newSyntaxError(err SyntaxError) *Node {
-    msg := err.Description()
-    return &Node{
-        t: V_ERROR,
-        v: int64(err.Code),
-        p: unsafe.Pointer(&msg),
+func unwrapError(err error) *Node {
+    if se, ok := err.(*Node); ok {
+        return se
+    }else if sse, ok := err.(Node); ok {
+        return &sse
+    } else {
+        msg := err.Error()
+        return &Node{
+            t: V_ERROR,
+            p: unsafe.Pointer(&msg),
+        }
     }
 }
 

vendor/github.com/bytedance/sonic/ast/iterator.go

@@ -82,26 +82,54 @@ type ObjectIterator struct {
     Iterator
 }
 
+func (self *ListIterator) next() *Node {
+next_start:
+    if !self.HasNext() {
+        return nil
+    } else {
+        n := self.p.nodeAt(self.i)
+        self.i++
+        if !n.Exists() {
+            goto next_start
+        }
+        return n
+    }
+}
+
 // Next scans through children of underlying V_ARRAY, 
 // copies each child to v, and returns .HasNext().
 func (self *ListIterator) Next(v *Node) bool {
-    if !self.HasNext() {
+    n := self.next()
+    if n == nil {
         return false
+    }
+    *v = *n
+    return true
+}
+
+func (self *ObjectIterator) next() *Pair {
+next_start:
+    if !self.HasNext() {
+        return nil
     } else {
-        *v, self.i = *self.p.nodeAt(self.i), self.i + 1
-        return true
+        n := self.p.pairAt(self.i)
+        self.i++
+        if !n.Value.Exists() {
+            goto next_start
+        }
+        return n
     }
 }
 
 // Next scans through children of underlying V_OBJECT, 
 // copies each child to v, and returns .HasNext().
 func (self *ObjectIterator) Next(p *Pair) bool {
-    if !self.HasNext() {
+    n := self.next()
+    if n == nil {
         return false
-    } else {
-        *p, self.i = *self.p.pairAt(self.i), self.i + 1
-        return true
     }
+    *p = *n
+    return true
 }
 
 // Sequence represents scanning path of single-layer nodes.
@@ -129,36 +157,39 @@ type Scanner func(path Sequence, node *Node) bool
 //
 // Especailly, if the node is not V_ARRAY or V_OBJECT, 
 // the node itself will be returned and Sequence.Index == -1.
+// 
+// NOTICE: A unsetted node WON'T trigger sc, but its index still counts into Path.Index
 func (self *Node) ForEach(sc Scanner) error {
     switch self.itype() {
     case types.V_ARRAY:
-        ns, err := self.UnsafeArray()
+        iter, err := self.Values()
         if err != nil {
             return err
         }
-        for i := range ns {
-            if !sc(Sequence{i, nil}, &ns[i]) {
-                return err
+        v := iter.next()
+        for v != nil {
+            if !sc(Sequence{iter.i-1, nil}, v) {
+                return nil
             }
+            v = iter.next()
         }
     case types.V_OBJECT:
-        ns, err := self.UnsafeMap()
+        iter, err := self.Properties()
         if err != nil {
             return err
         }
-        for i := range ns {
-            if !sc(Sequence{i, &ns[i].Key}, &ns[i].Value) {
-                return err
+        v := iter.next()
+        for v != nil {
+            if !sc(Sequence{iter.i-1, &v.Key}, &v.Value) {
+                return nil
             }
+            v = iter.next()
         }
     default:
+        if self.Check() != nil {
+            return self
+        }
         sc(Sequence{-1, nil}, self)
     }
-    return self.Check()
-}
-
-type PairSlice []Pair
-
-func (self PairSlice) Sort() {
-    radixQsort(self, 0, maxDepth(len(self)))
+    return nil
 }

vendor/github.com/bytedance/sonic/ast/parser.go

@@ -18,11 +18,15 @@ package ast
 
 import (
     `fmt`
+
     `github.com/bytedance/sonic/internal/native/types`
     `github.com/bytedance/sonic/internal/rt`
 )
 
-const _DEFAULT_NODE_CAP int = 16
+const (
+    _DEFAULT_NODE_CAP int = 8
+    _APPEND_GROW_SHIFT = 1
+)
 
 const (
     _ERR_NOT_FOUND      types.ParsingError = 33
@@ -30,7 +34,10 @@ const (
 )
 
 var (
+    // ErrNotExist means both key and value doesn't exist 
     ErrNotExist error = newError(_ERR_NOT_FOUND, "value not exists")
+
+    // ErrUnsupportType means API on the node is unsupported
     ErrUnsupportType error = newError(_ERR_UNSUPPORT_TYPE, "unsupported type")
 )
 
@@ -39,6 +46,7 @@ type Parser struct {
     s           string
     noLazy      bool
     skipValue   bool
+    dbuf        *byte
 }
 
 /** Parser Private Methods **/
@@ -107,7 +115,7 @@ func (self *Parser) lspace(sp int) int {
     return sp
 }
 
-func (self *Parser) decodeArray(ret []Node) (Node, types.ParsingError) {
+func (self *Parser) decodeArray(ret *linkedNodes) (Node, types.ParsingError) {
     sp := self.p
     ns := len(self.s)
 
@@ -119,7 +127,7 @@ func (self *Parser) decodeArray(ret []Node) (Node, types.ParsingError) {
     /* check for empty array */
     if self.s[self.p] == ']' {
         self.p++
-        return emptyArrayNode, 0
+        return Node{t: types.V_ARRAY}, 0
     }
 
     /* allocate array space and parse every element */
@@ -149,7 +157,7 @@ func (self *Parser) decodeArray(ret []Node) (Node, types.ParsingError) {
         }
 
         /* add the value to result */
-        ret = append(ret, val)
+        ret.Add(val)
         self.p = self.lspace(self.p)
 
         /* check for EOF */
@@ -160,17 +168,17 @@ func (self *Parser) decodeArray(ret []Node) (Node, types.ParsingError) {
         /* check for the next character */
         switch self.s[self.p] {
             case ',' : self.p++
-            case ']' : self.p++; return NewArray(ret), 0
-        default:
-            if val.isLazy() {
-                return newLazyArray(self, ret), 0
-            }
-            return Node{}, types.ERR_INVALID_CHAR
+            case ']' : self.p++; return newArray(ret), 0
+            default:
+                // if val.isLazy() {
+                //     return newLazyArray(self, ret), 0
+                // }
+                return Node{}, types.ERR_INVALID_CHAR
         }
     }
 }
 
-func (self *Parser) decodeObject(ret []Pair) (Node, types.ParsingError) {
+func (self *Parser) decodeObject(ret *linkedPairs) (Node, types.ParsingError) {
     sp := self.p
     ns := len(self.s)
 
@@ -182,7 +190,7 @@ func (self *Parser) decodeObject(ret []Pair) (Node, types.ParsingError) {
     /* check for empty object */
     if self.s[self.p] == '}' {
         self.p++
-        return emptyObjectNode, 0
+        return Node{t: types.V_OBJECT}, 0
     }
 
     /* decode each pair */
@@ -235,7 +243,8 @@ func (self *Parser) decodeObject(ret []Pair) (Node, types.ParsingError) {
         }
 
         /* add the value to result */
-        ret = append(ret, Pair{Key: key, Value: val})
+        // FIXME: ret's address may change here, thus previous referred node in ret may be invalid !!
+        ret.Add(Pair{Key: key, Value: val})
         self.p = self.lspace(self.p)
 
         /* check for EOF */
@@ -246,11 +255,11 @@ func (self *Parser) decodeObject(ret []Pair) (Node, types.ParsingError) {
         /* check for the next character */
         switch self.s[self.p] {
             case ',' : self.p++
-            case '}' : self.p++; return NewObject(ret), 0
+            case '}' : self.p++; return newObject(ret), 0
         default:
-            if val.isLazy() {
-                return newLazyObject(self, ret), 0
-            }
+            // if val.isLazy() {
+            //     return newLazyObject(self, ret), 0
+            // }
             return Node{}, types.ERR_INVALID_CHAR
         }
     }
@@ -290,15 +299,23 @@ func (self *Parser) Parse() (Node, types.ParsingError) {
         case types.V_FALSE   : return falseNode, 0
         case types.V_STRING  : return self.decodeString(val.Iv, val.Ep)
         case types.V_ARRAY:
-            if self.noLazy {
-                return self.decodeArray(make([]Node, 0, _DEFAULT_NODE_CAP))
+            if p := skipBlank(self.s, self.p); p >= self.p && self.s[p] == ']' {
+                self.p = p + 1
+                return Node{t: types.V_ARRAY}, 0
             }
-            return newLazyArray(self, make([]Node, 0, _DEFAULT_NODE_CAP)), 0
+            if self.noLazy {
+                return self.decodeArray(new(linkedNodes))
+            }
+            return newLazyArray(self), 0
         case types.V_OBJECT:
-            if self.noLazy {
-                return self.decodeObject(make([]Pair, 0, _DEFAULT_NODE_CAP))
+            if p := skipBlank(self.s, self.p); p >= self.p && self.s[p] == '}' {
+                self.p = p + 1
+                return Node{t: types.V_OBJECT}, 0
             }
-            return newLazyObject(self, make([]Pair, 0, _DEFAULT_NODE_CAP)), 0
+            if self.noLazy {
+                return self.decodeObject(new(linkedPairs))
+            }
+            return newLazyObject(self), 0
         case types.V_DOUBLE  : return NewNumber(self.s[val.Ep:self.p]), 0
         case types.V_INTEGER : return NewNumber(self.s[val.Ep:self.p]), 0
         default              : return Node{}, types.ParsingError(-val.Vt)
@@ -429,7 +446,7 @@ func (self *Node) skipNextNode() *Node {
     }
 
     parser, stack := self.getParserAndArrayStack()
-    ret := stack.v
+    ret := &stack.v
     sp := parser.p
     ns := len(parser.s)
 
@@ -458,7 +475,8 @@ func (self *Node) skipNextNode() *Node {
     }
 
     /* add the value to result */
-    ret = append(ret, val)
+    ret.Add(val)
+    self.l++
     parser.p = parser.lspace(parser.p)
 
     /* check for EOF */
@@ -470,12 +488,11 @@ func (self *Node) skipNextNode() *Node {
     switch parser.s[parser.p] {
     case ',':
         parser.p++
-        self.setLazyArray(parser, ret)
-        return &ret[len(ret)-1]
+        return ret.At(ret.Len()-1)
     case ']':
         parser.p++
         self.setArray(ret)
-        return &ret[len(ret)-1]
+        return ret.At(ret.Len()-1)
     default:
         return newSyntaxError(parser.syntaxError(types.ERR_INVALID_CHAR))
     }
@@ -487,7 +504,7 @@ func (self *Node) skipNextPair() (*Pair) {
     }
 
     parser, stack := self.getParserAndObjectStack()
-    ret := stack.v
+    ret := &stack.v
     sp := parser.p
     ns := len(parser.s)
 
@@ -541,7 +558,8 @@ func (self *Node) skipNextPair() (*Pair) {
     }
 
     /* add the value to result */
-    ret = append(ret, Pair{Key: key, Value: val})
+    ret.Add(Pair{Key: key, Value: val})
+    self.l++
     parser.p = parser.lspace(parser.p)
 
     /* check for EOF */
@@ -553,12 +571,11 @@ func (self *Node) skipNextPair() (*Pair) {
     switch parser.s[parser.p] {
     case ',':
         parser.p++
-        self.setLazyObject(parser, ret)
-        return &ret[len(ret)-1]
+        return ret.At(ret.Len()-1)
     case '}':
         parser.p++
         self.setObject(ret)
-        return &ret[len(ret)-1]
+        return ret.At(ret.Len()-1)
     default:
         return &Pair{key, *newSyntaxError(parser.syntaxError(types.ERR_INVALID_CHAR))}
     }
@@ -601,10 +618,30 @@ func LoadsUseNumber(src string) (int, interface{}, error) {
     }
 }
 
+// NewParser returns pointer of new allocated parser
 func NewParser(src string) *Parser {
     return &Parser{s: src}
 }
 
+// NewParser returns new allocated parser
+func NewParserObj(src string) Parser {
+    return Parser{s: src}
+}
+
+// decodeNumber controls if parser decodes the number values instead of skip them
+//   WARN: once you set decodeNumber(true), please set decodeNumber(false) before you drop the parser 
+//   otherwise the memory CANNOT be reused
+func (self *Parser) decodeNumber(decode bool) {
+    if !decode && self.dbuf != nil {
+        types.FreeDbuf(self.dbuf)
+        self.dbuf = nil
+        return
+    }
+    if decode && self.dbuf == nil {
+        self.dbuf = types.NewDbuf()
+    }
+}
+
 // ExportError converts types.ParsingError to std Error
 func (self *Parser) ExportError(err types.ParsingError) error {
     if err == _ERR_NOT_FOUND {

vendor/github.com/bytedance/sonic/ast/sort.go

@@ -1,206 +0,0 @@
-/*
- * Copyright 2021 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 ast
-
-// Algorithm 3-way Radix Quicksort, d means the radix.
-// Reference: https://algs4.cs.princeton.edu/51radix/Quick3string.java.html
-func radixQsort(kvs PairSlice, d, maxDepth int) {
-    for len(kvs) > 11 {
-        // To avoid the worst case of quickSort (time: O(n^2)), use introsort here.
-        // Reference: https://en.wikipedia.org/wiki/Introsort and
-        // https://github.com/golang/go/issues/467
-        if maxDepth == 0 {
-            heapSort(kvs, 0, len(kvs))
-            return
-        }
-        maxDepth--
-
-        p := pivot(kvs, d)
-        lt, i, gt := 0, 0, len(kvs)
-        for i < gt {
-            c := byteAt(kvs[i].Key, d)
-            if c < p {
-                swap(kvs, lt, i)
-                i++
-                lt++
-            } else if c > p {
-                gt--
-                swap(kvs, i, gt)
-            } else {
-                i++
-            }
-        }
-
-        // kvs[0:lt] < v = kvs[lt:gt] < kvs[gt:len(kvs)]
-        // Native implemention:
-        //     radixQsort(kvs[:lt], d, maxDepth)
-        //     if p > -1 {
-        //         radixQsort(kvs[lt:gt], d+1, maxDepth)
-        //     }
-        //     radixQsort(kvs[gt:], d, maxDepth)
-        // Optimize as follows: make recursive calls only for the smaller parts.
-        // Reference: https://www.geeksforgeeks.org/quicksort-tail-call-optimization-reducing-worst-case-space-log-n/
-        if p == -1 {
-            if lt > len(kvs) - gt {
-                radixQsort(kvs[gt:], d, maxDepth)
-                kvs = kvs[:lt]
-            } else {
-                radixQsort(kvs[:lt], d, maxDepth)
-                kvs = kvs[gt:]
-            }
-        } else {
-            ml := maxThree(lt, gt-lt, len(kvs)-gt)
-            if ml == lt {
-                radixQsort(kvs[lt:gt], d+1, maxDepth)
-                radixQsort(kvs[gt:], d, maxDepth)
-                kvs = kvs[:lt]
-            } else if ml == gt-lt {
-                radixQsort(kvs[:lt], d, maxDepth)
-                radixQsort(kvs[gt:], d, maxDepth)
-                kvs = kvs[lt:gt]
-                d += 1
-            } else {
-                radixQsort(kvs[:lt], d, maxDepth)
-                radixQsort(kvs[lt:gt], d+1, maxDepth)
-                kvs = kvs[gt:] 
-            }
-        }
-    }
-    insertRadixSort(kvs, d)
-}
-
-func insertRadixSort(kvs PairSlice, d int) {
-    for i := 1; i < len(kvs); i++ {
-        for j := i; j > 0 && lessFrom(kvs[j].Key, kvs[j-1].Key, d); j-- {
-            swap(kvs, j, j-1)
-        }
-    }
-}
-
-func pivot(kvs PairSlice, d int) int {
-    m := len(kvs) >> 1
-    if len(kvs) > 40 {
-        // Tukey's ``Ninther,'' median of three mediankvs of three.
-        t := len(kvs) / 8
-        return medianThree(
-            medianThree(byteAt(kvs[0].Key, d), byteAt(kvs[t].Key, d), byteAt(kvs[2*t].Key, d)),
-            medianThree(byteAt(kvs[m].Key, d), byteAt(kvs[m-t].Key, d), byteAt(kvs[m+t].Key, d)),
-            medianThree(byteAt(kvs[len(kvs)-1].Key, d),
-                byteAt(kvs[len(kvs)-1-t].Key, d),
-                byteAt(kvs[len(kvs)-1-2*t].Key, d)))
-    }
-    return medianThree(byteAt(kvs[0].Key, d), byteAt(kvs[m].Key, d), byteAt(kvs[len(kvs)-1].Key, d))
-}
-
-func medianThree(i, j, k int) int {
-    if i > j {
-        i, j = j, i
-    } // i < j
-    if k < i {
-        return i
-    }
-    if k > j {
-        return j
-    }
-    return k
-}
-
-func maxThree(i, j, k int) int {
-    max := i
-    if max < j {
-        max = j
-    }
-    if max < k {
-        max = k
-    }
-    return max
-}
-
-// maxDepth returns a threshold at which quicksort should switch
-// to heapsort. It returnkvs 2*ceil(lg(n+1)).
-func maxDepth(n int) int {
-    var depth int
-    for i := n; i > 0; i >>= 1 {
-        depth++
-    }
-    return depth * 2
-}
-
-// siftDown implements the heap property on kvs[lo:hi].
-// first is an offset into the array where the root of the heap lies.
-func siftDown(kvs PairSlice, lo, hi, first int) {
-    root := lo
-    for {
-        child := 2*root + 1
-        if child >= hi {
-            break
-        }
-        if child+1 < hi && kvs[first+child].Key < kvs[first+child+1].Key {
-            child++
-        }
-        if kvs[first+root].Key >= kvs[first+child].Key {
-            return
-        }
-        swap(kvs, first+root, first+child)
-        root = child
-    }
-}
-
-func heapSort(kvs PairSlice, a, b int) {
-    first := a
-    lo := 0
-    hi := b - a
-
-    // Build heap with the greatest element at top.
-    for i := (hi - 1) / 2; i >= 0; i-- {
-        siftDown(kvs, i, hi, first)
-    }
-
-    // Pop elements, the largest first, into end of kvs.
-    for i := hi - 1; i >= 0; i-- {
-        swap(kvs, first, first+i)
-        siftDown(kvs, lo, i, first)
-    }
-}
-
-// Note that Pair.Key is NOT pointed to Pair.m when map key is integer after swap
-func swap(kvs PairSlice, a, b int) {
-    kvs[a].Key, kvs[b].Key = kvs[b].Key, kvs[a].Key
-    kvs[a].Value, kvs[b].Value = kvs[b].Value, kvs[a].Value
-}
-
-// Compare two strings from the pos d.
-func lessFrom(a, b string, d int) bool {
-    l := len(a)
-    if l > len(b) {
-        l = len(b)
-    }
-    for i := d; i < l; i++ {
-        if a[i] == b[i] {
-            continue
-        }
-        return a[i] < b[i]
-    }
-    return len(a) < len(b)
-}
-
-func byteAt(b string, p int) int {
-    if p < len(b) {
-        return int(b[p])
-    }
-    return -1
-}

vendor/github.com/bytedance/sonic/bench-arm.sh

@@ -1,14 +0,0 @@
-#!/usr/bin/env bash
-
-pwd=$(pwd)
-export SONIC_NO_ASYNC_GC=1
-
-cd $pwd/ast
-go test -benchmem -run=^$ -benchtime=1000000x -bench "^(BenchmarkGet.*|BenchmarkSet.*)$"
-
-go test -benchmem -run=^$ -benchtime=10000x -bench "^(BenchmarkParser_.*|BenchmarkEncode.*)$"
-
-go test -benchmem -run=^$ -benchtime=10000000x -bench "^(BenchmarkNodeGetByPath|BenchmarkStructGetByPath|BenchmarkNodeIndex|BenchmarkStructIndex|BenchmarkSliceIndex|BenchmarkMapIndex|BenchmarkNodeGet|BenchmarkSliceGet|BenchmarkMapGet|BenchmarkNodeSet|BenchmarkMapSet|BenchmarkNodeSetByIndex|BenchmarkSliceSetByIndex|BenchmarkStructSetByIndex|BenchmarkNodeUnset|BenchmarkMapUnset|BenchmarkNodUnsetByIndex|BenchmarkSliceUnsetByIndex|BenchmarkNodeAdd|BenchmarkSliceAdd|BenchmarkMapAdd)$"
-
-unset SONIC_NO_ASYNC_GC
-cd $pwd

vendor/github.com/bytedance/sonic/bench.py

@@ -1,134 +0,0 @@
-#!/usr/bin/env python3
-
-# 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.
-
-import tempfile
-import os
-import subprocess
-import argparse
-
-gbench_prefix = "SONIC_NO_ASYNC_GC=1 go test -benchmem -run=none "
-
-def run(cmd):
-    print(cmd)
-    if os.system(cmd):
-        print ("Failed to run cmd: %s"%(cmd))
-        exit(1)
-
-def run_s(cmd):
-    print (cmd)
-    try:
-        res = os.popen(cmd)
-    except subprocess.CalledProcessError as e:
-        if e.returncode:
-            print (e.output)
-            exit(1)
-    return res.read()
-
-def run_r(cmd):
-    print (cmd)
-    try:
-        cmds = cmd.split(' ')
-        data = subprocess.check_output(cmds, stderr=subprocess.STDOUT)
-    except subprocess.CalledProcessError as e:
-        if e.returncode:
-            print (e.output)
-            exit(1)
-    return data.decode("utf-8") 
-
-def compare(args):
-    # detech current branch.
-    # result = run_r("git branch")
-    current_branch = run_s("git status | head -n1 | sed 's/On branch //'")
-    # for br in result.split('\n'):
-    #     if br.startswith("* "):
-    #         current_branch = br.lstrip('* ')
-    #         break
-
-    if not current_branch:
-        print ("Failed to detech current branch")
-        return None
-    
-    # get the current diff
-    (fd, diff) = tempfile.mkstemp()
-    run("git diff > %s"%diff)
-
-    # early return if currrent is main branch.
-    print ("Current branch: %s"%(current_branch))
-    if current_branch == "main":
-        print ("Cannot compare at the main branch.Please build a new branch")
-        return None
-
-    # benchmark current branch    
-    (fd, target) = tempfile.mkstemp(".target.txt")
-    run("%s %s ./... 2>&1 | tee %s" %(gbench_prefix, args, target))
-
-    # trying to switch to the latest main branch
-    run("git checkout -- .")
-    if current_branch != "main":
-        run("git checkout main")
-    run("git pull --allow-unrelated-histories origin main")
-
-    # benchmark main branch
-    (fd, main) = tempfile.mkstemp(".main.txt")
-    run("%s %s ./... 2>&1 | tee %s" %(gbench_prefix, args, main))
-
-    # diff the result
-    # benchstat = "go get golang.org/x/perf/cmd/benchstat && go install golang.org/x/perf/cmd/benchstat"
-    run( "benchstat -sort=delta %s %s"%(main, target))
-    run("git checkout -- .")
-
-    # restore branch
-    if current_branch != "main":
-        run("git checkout %s"%(current_branch))
-    run("patch -p1 < %s" % (diff))
-    return target
-
-def main():
-    argparser = argparse.ArgumentParser(description='Tools to test the performance. Example: ./bench.py -b Decoder_Generic_Sonic -c')
-    argparser.add_argument('-b', '--bench', dest='filter', required=False,
-        help='Specify the filter for golang benchmark')
-    argparser.add_argument('-c', '--compare', dest='compare', action='store_true', required=False,
-        help='Compare with the main benchmarking')
-    argparser.add_argument('-t', '--times', dest='times', required=False,
-        help='benchmark the times')
-    argparser.add_argument('-r', '--repeat_times', dest='count', required=False,
-        help='benchmark the count')
-    args = argparser.parse_args()
-    
-    if args.filter:
-        gbench_args = "-bench=%s"%(args.filter)
-    else:
-        gbench_args = "-bench=."
-        
-    if args.times:
-        gbench_args += " -benchtime=%s"%(args.times)
-        
-    if args.count:
-        gbench_args += " -count=%s"%(args.count)
-    else:
-        gbench_args += " -count=10"
-
-    if args.compare:
-        target = compare(gbench_args)
-    else:
-        target = None
-
-    if not target:
-        (fd, target) = tempfile.mkstemp(".target.txt")
-        run("%s %s ./... 2>&1 | tee %s" %(gbench_prefix, gbench_args, target))
-
-if __name__ == "__main__":
-    main()

vendor/github.com/bytedance/sonic/bench.sh

@@ -1,27 +0,0 @@
-#!/usr/bin/env bash
-
-pwd=$(pwd)
-export SONIC_NO_ASYNC_GC=1
-
-cd $pwd/encoder
-go test -benchmem -run=^$ -benchtime=100000x -bench "^(BenchmarkEncoder_.*)$"
-
-cd $pwd/decoder
-go test -benchmem -run=^$ -benchtime=100000x -bench "^(BenchmarkDecoder_.*)$"
-
-cd $pwd/ast
-go test -benchmem -run=^$ -benchtime=1000000x -bench "^(BenchmarkGet.*|BenchmarkSet.*)$"
-
-go test -benchmem -run=^$ -benchtime=10000x -bench "^(BenchmarkParser_.*|BenchmarkEncode.*)$"
-
-go test -benchmem -run=^$ -benchtime=10000000x -bench "^(BenchmarkNodeGetByPath|BenchmarkStructGetByPath|BenchmarkNodeIndex|BenchmarkStructIndex|BenchmarkSliceIndex|BenchmarkMapIndex|BenchmarkNodeGet|BenchmarkSliceGet|BenchmarkMapGet|BenchmarkNodeSet|BenchmarkMapSet|BenchmarkNodeSetByIndex|BenchmarkSliceSetByIndex|BenchmarkStructSetByIndex|BenchmarkNodeUnset|BenchmarkMapUnset|BenchmarkNodUnsetByIndex|BenchmarkSliceUnsetByIndex|BenchmarkNodeAdd|BenchmarkSliceAdd|BenchmarkMapAdd)$"
-
-cd $pwd/external_jsonlib_test/benchmark_test
-go test -benchmem -run=^$ -benchtime=100000x -bench "^(BenchmarkEncoder_.*|BenchmarkDecoder_.*)$"
-
-go test -benchmem -run=^$ -benchtime=1000000x -bench "^(BenchmarkGet.*|BenchmarkSet.*)$"
-
-go test -benchmem -run=^$ -benchtime=10000x -bench "^(BenchmarkParser_.*)$"
-
-unset SONIC_NO_ASYNC_GC
-cd $pwd

vendor/github.com/bytedance/sonic/check_branch_name.sh

@@ -1,10 +0,0 @@
-#!/usr/bin/env bash
-
-current=$(git status | head -n1 | sed 's/On branch //')
-name=${1:-$current}
-if [[ ! $name =~ ^(((opt(imize)?|feat(ure)?|doc|(bug|hot)?fix|test|refact(or)?|ci)/.+)|(main|develop)|(release/.+)|(release-v[0-9]+\.[0-9]+)|(release/v[0-9]+\.[0-9]+\.[0-9]+(-[a-z0-9.]+(\+[a-z0-9.]+)?)?)|revert-[a-z0-9]+)$ ]]; then
-    echo "branch name '$name' is invalid"
-    exit 1
-else
-    echo "branch name '$name' is valid"
-fi

vendor/github.com/bytedance/sonic/compat.go

@@ -1,4 +1,4 @@
-// +build !amd64 go1.21
+// +build !amd64 !go1.16 go1.22
 
 /*
  * Copyright 2021 ByteDance Inc.

vendor/github.com/bytedance/sonic/decoder/decoder_amd64.go

@@ -1,4 +1,4 @@
-// +build amd64,go1.15,!go1.21
+// +build amd64,go1.16,!go1.22
 
 /*
 * Copyright 2023 ByteDance Inc.
@@ -25,6 +25,10 @@ import (
 // Decoder is the decoder context object
 type Decoder = decoder.Decoder
 
+// SyntaxError represents json syntax error
+type SyntaxError = decoder.SyntaxError
+
+// MismatchTypeError represents dismatching between json and object
 type MismatchTypeError = decoder.MismatchTypeError
 
 // Options for decode.
@@ -42,8 +46,6 @@ const (
 // StreamDecoder is the decoder context object for streaming input.
 type StreamDecoder = decoder.StreamDecoder
 
-type SyntaxError = decoder.SyntaxError
-
 var (
     // NewDecoder creates a new decoder instance.
     NewDecoder = decoder.NewDecoder

vendor/github.com/bytedance/sonic/decoder/decoder_compat.go

@@ -1,4 +1,4 @@
-// +build !amd64 go1.21
+// +build !amd64 !go1.16 go1.22
 
 /*
 * Copyright 2023 ByteDance Inc.
@@ -14,28 +14,34 @@
 * 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 decoder
 
 import (
-     `encoding/json`
-     `bytes`
-     `reflect`
-     `github.com/bytedance/sonic/internal/native/types`
-     `github.com/bytedance/sonic/option`
-     `io`
+    `bytes`
+    `encoding/json`
+    `io`
+    `reflect`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/option`
 )
 
-const (
-     _F_use_int64 = iota
-     _F_use_number
-     _F_disable_urc
-     _F_disable_unknown
-     _F_copy_string
-     _F_validate_string
+func init() {
+     println("WARNING: sonic only supports Go1.16~1.20 && CPU amd64, but your environment is not suitable")
+}
 
-     _F_allow_control = 31
+const (
+     _F_use_int64       = 0
+     _F_disable_urc     = 2
+     _F_disable_unknown = 3
+     _F_copy_string     = 4
+ 
+     _F_use_number      = types.B_USE_NUMBER
+     _F_validate_string = types.B_VALIDATE_STRING
+     _F_allow_control   = types.B_ALLOW_CONTROL
 )
 
 type Options uint64
@@ -163,34 +169,26 @@ func Pretouch(vt reflect.Type, opts ...option.CompileOption) error {
      return nil
 }
 
-type StreamDecoder struct {
-   r       io.Reader
-   buf     []byte
-   scanp   int
-   scanned int64
-   err     error
-   Decoder
-}
+type StreamDecoder = json.Decoder
 
 // NewStreamDecoder adapts to encoding/json.NewDecoder API.
 //
 // NewStreamDecoder returns a new decoder that reads from r.
 func NewStreamDecoder(r io.Reader) *StreamDecoder {
-   return &StreamDecoder{r : r}
+   return json.NewDecoder(r)
 }
 
-// Decode decodes input stream into val with corresponding data. 
-// Redundantly bytes may be read and left in its buffer, and can be used at next call.
-// 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) {
-   dec := json.NewDecoder(self.r)
-   if (self.f | uint64(OptionUseNumber)) != 0  {
-       dec.UseNumber()
-   }
-   if (self.f | uint64(OptionDisableUnknown)) != 0  {
-       dec.DisallowUnknownFields()
-   }
-   return dec.Decode(val)
+// SyntaxError represents json syntax error
+type SyntaxError json.SyntaxError
+
+// Description
+func (s SyntaxError) Description() string {
+     return (*json.SyntaxError)(unsafe.Pointer(&s)).Error()
+}
+// Error
+func (s SyntaxError) Error() string {
+     return (*json.SyntaxError)(unsafe.Pointer(&s)).Error()
 }
 
+// MismatchTypeError represents dismatching between json and object
+type MismatchTypeError json.UnmarshalTypeError

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

@@ -1,4 +1,4 @@
-// +build amd64,go1.15,!go1.21
+// +build amd64,go1.16,!go1.22
 
 /*
  * Copyright 2023 ByteDance Inc.

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

@@ -1,4 +1,4 @@
-// +build !amd64 go1.21
+// +build !amd64 !go1.16 go1.22
 
 /*
 * Copyright 2023 ByteDance Inc.
@@ -27,6 +27,10 @@ import (
     `github.com/bytedance/sonic/option`
 )
 
+func init() {
+    println("WARNING: sonic only supports Go1.16~1.20 && CPU amd64, but your environment is not suitable")
+}
+
 // Options is a set of encoding options.
 type Options uint64
 
@@ -212,23 +216,12 @@ func Valid(data []byte) (ok bool, start int) {
 }
 
 // StreamEncoder uses io.Writer as 
-type StreamEncoder struct {
-   w io.Writer
-   Encoder
-}
+type StreamEncoder = json.Encoder
 
 // NewStreamEncoder adapts to encoding/json.NewDecoder API.
 //
 // NewStreamEncoder returns a new encoder that write to w.
 func NewStreamEncoder(w io.Writer) *StreamEncoder {
-   return &StreamEncoder{w: w}
+   return json.NewEncoder(w)
 }
 
-// Encode encodes interface{} as JSON to io.Writer
-func (enc *StreamEncoder) Encode(val interface{}) (err error) {
-   jenc := json.NewEncoder(enc.w)
-   jenc.SetEscapeHTML((enc.Opts & EscapeHTML) != 0)
-   jenc.SetIndent(enc.prefix, enc.indent)
-   err = jenc.Encode(val)
-   return err
-}

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

@@ -30,14 +30,14 @@ import (
 )
 
 const (
-    _F_use_int64 = iota
-    _F_use_number
-    _F_disable_urc
-    _F_disable_unknown
-    _F_copy_string
-    _F_validate_string
+    _F_use_int64       = 0
+    _F_disable_urc     = 2
+    _F_disable_unknown = 3
+    _F_copy_string     = 4
 
-    _F_allow_control = 31
+    _F_use_number      = types.B_USE_NUMBER
+    _F_validate_string = types.B_VALIDATE_STRING
+    _F_allow_control   = types.B_ALLOW_CONTROL
 )
 
 type Options uint64

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

@@ -44,35 +44,12 @@ func (self SyntaxError) Description() string {
 }
 
 func (self SyntaxError) description() string {
-    i := 16
-    p := self.Pos - i
-    q := self.Pos + i
-
     /* check for empty source */
     if self.Src == "" {
         return fmt.Sprintf("no sources available: %#v", self)
     }
 
-    /* prevent slicing before the beginning */
-    if p < 0 {
-        p, q, i = 0, q - p, i + p
-    }
-
-    /* prevent slicing beyond the end */
-    if n := len(self.Src); q > n {
-        n = q - n
-        q = len(self.Src)
-
-        /* move the left bound if possible */
-        if p > n {
-            i += n
-            p -= n
-        }
-    }
-
-    /* left and right length */
-    x := clamp_zero(i)
-    y := clamp_zero(q - p - i - 1)
+    p, x, q, y := calcBounds(len(self.Src), self.Pos)
 
     /* compose the error description */
     return fmt.Sprintf(
@@ -85,6 +62,39 @@ func (self SyntaxError) description() string {
     )
 }
 
+func calcBounds(size int, pos int) (lbound int, lwidth int, rbound int, rwidth int) {
+    if pos >= size || pos < 0 {
+        return 0, 0, size, 0
+    }
+
+    i := 16
+    lbound = pos - i
+    rbound = pos + i
+
+    /* prevent slicing before the beginning */
+    if lbound < 0 {
+        lbound, rbound, i = 0, rbound - lbound, i + lbound
+    }
+
+    /* prevent slicing beyond the end */
+    if n := size; rbound > n {
+        n = rbound - n
+        rbound = size
+
+        /* move the left bound if possible */
+        if lbound > n {
+            i += n
+            lbound -= n
+        }
+    }
+
+    /* left and right length */
+    lwidth = clamp_zero(i)
+    rwidth = clamp_zero(rbound - lbound - i - 1)
+
+    return
+}
+
 func (self SyntaxError) Message() string {
     if self.Msg == "" {
         return self.Code.Message()
@@ -107,16 +117,19 @@ var stackOverflow = &json.UnsupportedValueError {
     Value : reflect.ValueOf("..."),
 }
 
-//go:nosplit
 func error_wrap(src string, pos int, code types.ParsingError) error {
-    return SyntaxError {
+    return *error_wrap_heap(src, pos, code)
+}
+
+//go:noinline
+func error_wrap_heap(src string, pos int, code types.ParsingError) *SyntaxError {
+    return &SyntaxError {
         Pos  : pos,
         Src  : src,
         Code : code,
     }
 }
 
-//go:nosplit
 func error_type(vt *rt.GoType) error {
     return &json.UnmarshalTypeError{Type: vt.Pack()}
 }
@@ -158,7 +171,6 @@ func (self MismatchTypeError) Description() string {
     return fmt.Sprintf("Mismatch type %s with value %s %s", self.Type.String(), swithchJSONType(self.Src, self.Pos), se.description())
 }
 
-//go:nosplit
 func error_mismatch(src string, pos int, vt *rt.GoType) error {
     return &MismatchTypeError {
         Pos  : pos,
@@ -167,12 +179,10 @@ func error_mismatch(src string, pos int, vt *rt.GoType) error {
     }
 }
 
-//go:nosplit
 func error_field(name string) error {
     return errors.New("json: unknown field " + strconv.Quote(name))
 }
 
-//go:nosplit
 func error_value(value string, vtype reflect.Type) error {
     return &json.UnmarshalTypeError {
         Type  : vtype,

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

@@ -1,776 +0,0 @@
-// +build go1.15,!go1.17
-
-/*
- * Copyright 2021 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 decoder
-
-import (
-    `encoding/json`
-    `fmt`
-    `reflect`
-    `strconv`
-
-    `github.com/bytedance/sonic/internal/jit`
-    `github.com/bytedance/sonic/internal/native`
-    `github.com/bytedance/sonic/internal/native/types`
-    `github.com/twitchyliquid64/golang-asm/obj`
-    `github.com/twitchyliquid64/golang-asm/obj/x86`
-)
-
-/** Crucial Registers:
- *
- *      ST(BX)  : ro, decoder stack
- *      DF(R10) : ro, decoder flags
- *      EP(R11) : wo, error pointer
- *      IP(R12) : ro, input pointer
- *      IL(R13) : ro, input length
- *      IC(R14) : rw, input cursor
- *      VP(R15) : ro, value pointer (to an interface{})
- */
-
-const (
-    _VD_args   = 8      // 8 bytes  for passing arguments to this functions
-    _VD_fargs  = 64     // 64 bytes for passing arguments to other Go functions
-    _VD_saves  = 40     // 40 bytes for saving the registers before CALL instructions
-    _VD_locals = 88     // 88 bytes for local variables
-)
-
-const (
-    _VD_offs = _VD_fargs + _VD_saves + _VD_locals
-    _VD_size = _VD_offs + 8     // 8 bytes for the parent frame pointer
-)
-
-var (
-    _VAR_ss = _VAR_ss_Vt
-    _VAR_df = jit.Ptr(_SP, _VD_fargs + _VD_saves)
-)
-
-var (
-    _VAR_ss_Vt = jit.Ptr(_SP, _VD_fargs + _VD_saves + 8)
-    _VAR_ss_Dv = jit.Ptr(_SP, _VD_fargs + _VD_saves + 16)
-    _VAR_ss_Iv = jit.Ptr(_SP, _VD_fargs + _VD_saves + 24)
-    _VAR_ss_Ep = jit.Ptr(_SP, _VD_fargs + _VD_saves + 32)
-    _VAR_ss_Db = jit.Ptr(_SP, _VD_fargs + _VD_saves + 40)
-    _VAR_ss_Dc = jit.Ptr(_SP, _VD_fargs + _VD_saves + 48)
-)
-
-var (
-    _VAR_cs_LR = jit.Ptr(_SP, _VD_fargs + _VD_saves + 56)
-    _VAR_cs_p = jit.Ptr(_SP, _VD_fargs + _VD_saves + 64)
-    _VAR_cs_n = jit.Ptr(_SP, _VD_fargs + _VD_saves + 72)
-    _VAR_cs_d = jit.Ptr(_SP, _VD_fargs + _VD_saves + 80)
-)
-
-type _ValueDecoder struct {
-    jit.BaseAssembler
-}
-
-func (self *_ValueDecoder) build() uintptr {
-    self.Init(self.compile)
-    return *(*uintptr)(self.Load("decode_value", _VD_size, _VD_args, argPtrs_generic, localPtrs_generic))
-}
-
-/** Function Calling Helpers **/
-
-func (self *_ValueDecoder) save(r ...obj.Addr) {
-    for i, v := range r {
-        if i > _VD_saves / 8 - 1 {
-            panic("too many registers to save")
-        } else {
-            self.Emit("MOVQ", v, jit.Ptr(_SP, _VD_fargs + int64(i) * 8))
-        }
-    }
-}
-
-func (self *_ValueDecoder) load(r ...obj.Addr) {
-    for i, v := range r {
-        if i > _VD_saves / 8 - 1 {
-            panic("too many registers to load")
-        } else {
-            self.Emit("MOVQ", jit.Ptr(_SP, _VD_fargs + int64(i) * 8), v)
-        }
-    }
-}
-
-func (self *_ValueDecoder) call(fn obj.Addr) {
-    self.Emit("MOVQ", fn, _AX)  // MOVQ ${fn}, AX
-    self.Rjmp("CALL", _AX)      // CALL AX
-}
-
-func (self *_ValueDecoder) call_go(fn obj.Addr) {
-    self.save(_REG_go...)   // SAVE $REG_go
-    self.call(fn)           // CALL ${fn}
-    self.load(_REG_go...)   // LOAD $REG_go
-}
-
-/** Decoder Assembler **/
-
-const (
-    _S_val = iota + 1
-    _S_arr
-    _S_arr_0
-    _S_obj
-    _S_obj_0
-    _S_obj_delim
-    _S_obj_sep
-)
-
-const (
-    _S_omask_key = (1 << _S_obj_0) | (1 << _S_obj_sep)
-    _S_omask_end = (1 << _S_obj_0) | (1 << _S_obj)
-    _S_vmask = (1 << _S_val) | (1 << _S_arr_0)
-)
-
-const (
-    _A_init_len = 1
-    _A_init_cap = 16
-)
-
-const (
-    _ST_Sp = 0
-    _ST_Vt = _PtrBytes
-    _ST_Vp = _PtrBytes * (types.MAX_RECURSE + 1)
-)
-
-var (
-    _V_true  = jit.Imm(int64(pbool(true)))
-    _V_false = jit.Imm(int64(pbool(false)))
-    _F_value = jit.Imm(int64(native.S_value))
-)
-
-var (
-    _V_max     = jit.Imm(int64(types.V_MAX))
-    _E_eof     = jit.Imm(int64(types.ERR_EOF))
-    _E_invalid = jit.Imm(int64(types.ERR_INVALID_CHAR))
-    _E_recurse = jit.Imm(int64(types.ERR_RECURSE_EXCEED_MAX))
-)
-
-var (
-    _F_convTslice    = jit.Func(convTslice)
-    _F_convTstring   = jit.Func(convTstring)
-    _F_invalid_vtype = jit.Func(invalid_vtype)
-)
-
-var (
-    _T_map     = jit.Type(reflect.TypeOf((map[string]interface{})(nil)))
-    _T_bool    = jit.Type(reflect.TypeOf(false))
-    _T_int64   = jit.Type(reflect.TypeOf(int64(0)))
-    _T_eface   = jit.Type(reflect.TypeOf((*interface{})(nil)).Elem())
-    _T_slice   = jit.Type(reflect.TypeOf(([]interface{})(nil)))
-    _T_string  = jit.Type(reflect.TypeOf(""))
-    _T_number  = jit.Type(reflect.TypeOf(json.Number("")))
-    _T_float64 = jit.Type(reflect.TypeOf(float64(0)))
-)
-
-var _R_tab = map[int]string {
-    '[': "_decode_V_ARRAY",
-    '{': "_decode_V_OBJECT",
-    ':': "_decode_V_KEY_SEP",
-    ',': "_decode_V_ELEM_SEP",
-    ']': "_decode_V_ARRAY_END",
-    '}': "_decode_V_OBJECT_END",
-}
-
-func (self *_ValueDecoder) compile() {
-    self.Emit("SUBQ", jit.Imm(_VD_size), _SP)       // SUBQ $_VD_size, SP
-    self.Emit("MOVQ", _BP, jit.Ptr(_SP, _VD_offs))  // MOVQ BP, _VD_offs(SP)
-    self.Emit("LEAQ", jit.Ptr(_SP, _VD_offs), _BP)  // LEAQ _VD_offs(SP), BP
-
-    /* initialize the state machine */
-    self.Emit("XORL", _CX, _CX)                                 // XORL CX, CX
-    self.Emit("MOVQ", _DF, _VAR_df)                             // MOVQ DF, df
-    /* initialize digital buffer first */
-    self.Emit("MOVQ", jit.Imm(_MaxDigitNums), _VAR_ss_Dc)       // MOVQ $_MaxDigitNums, ss.Dcap
-    self.Emit("LEAQ", jit.Ptr(_ST, _DbufOffset), _AX)           // LEAQ _DbufOffset(ST), AX
-    self.Emit("MOVQ", _AX, _VAR_ss_Db)                          // MOVQ AX, ss.Dbuf
-    /* add ST offset */
-    self.Emit("ADDQ", jit.Imm(_FsmOffset), _ST)                 // ADDQ _FsmOffset, _ST
-    self.Emit("MOVQ", _CX, jit.Ptr(_ST, _ST_Sp))                // MOVQ CX, ST.Sp
-    self.WriteRecNotAX(0, _VP, jit.Ptr(_ST, _ST_Vp), false)                // MOVQ VP, ST.Vp[0]
-    self.Emit("MOVQ", jit.Imm(_S_val), jit.Ptr(_ST, _ST_Vt))    // MOVQ _S_val, ST.Vt[0]
-    self.Sjmp("JMP" , "_next")                                  // JMP  _next
-
-    /* set the value from previous round */
-    self.Link("_set_value")                                 // _set_value:
-    self.Emit("MOVL" , jit.Imm(_S_vmask), _DX)              // MOVL  _S_vmask, DX
-    self.Emit("MOVQ" , jit.Ptr(_ST, _ST_Sp), _CX)           // MOVQ  ST.Sp, CX
-    self.Emit("MOVQ" , jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)   // MOVQ  ST.Vt[CX], AX
-    self.Emit("BTQ"  , _AX, _DX)                            // BTQ   AX, DX
-    self.Sjmp("JNC"  , "_vtype_error")                      // JNC   _vtype_error
-    self.Emit("XORL" , _SI, _SI)                            // XORL  SI, SI
-    self.Emit("SUBQ" , jit.Imm(1), jit.Ptr(_ST, _ST_Sp))    // SUBQ  $1, ST.Sp
-    self.Emit("XCHGQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)   // XCHGQ ST.Vp[CX], SI
-    self.Emit("MOVQ" , _R8, jit.Ptr(_SI, 0))                // MOVQ  R8, (SI)
-    self.WriteRecNotAX(1, _R9, jit.Ptr(_SI, 8), false)           // MOVQ  R9, 8(SI)
-
-    /* check for value stack */
-    self.Link("_next")                              // _next:
-    self.Emit("MOVQ" , jit.Ptr(_ST, _ST_Sp), _AX)   // MOVQ  ST.Sp, AX
-    self.Emit("TESTQ", _AX, _AX)                    // TESTQ AX, AX
-    self.Sjmp("JS"   , "_return")                   // JS    _return
-
-    /* fast path: test up to 4 characters manually */
-    self.Emit("CMPQ"   , _IC, _IL)                      // CMPQ    IC, IL
-    self.Sjmp("JAE"    , "_decode_V_EOF")               // JAE     _decode_V_EOF
-    self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX)  // MOVBQZX (IP)(IC), AX
-    self.Emit("MOVQ"   , jit.Imm(_BM_space), _DX)       // MOVQ    _BM_space, DX
-    self.Emit("CMPQ"   , _AX, jit.Imm(' '))             // CMPQ    AX, $' '
-    self.Sjmp("JA"     , "_decode_fast")                // JA      _decode_fast
-    self.Emit("BTQ"    , _AX, _DX)                      // BTQ     _AX, _DX
-    self.Sjmp("JNC"    , "_decode_fast")                // JNC     _decode_fast
-    self.Emit("ADDQ"   , jit.Imm(1), _IC)               // ADDQ    $1, IC
-
-    /* at least 1 to 3 spaces */
-    for i := 0; i < 3; i++ {
-        self.Emit("CMPQ"   , _IC, _IL)                      // CMPQ    IC, IL
-        self.Sjmp("JAE"    , "_decode_V_EOF")               // JAE     _decode_V_EOF
-        self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX)  // MOVBQZX (IP)(IC), AX
-        self.Emit("CMPQ"   , _AX, jit.Imm(' '))             // CMPQ    AX, $' '
-        self.Sjmp("JA"     , "_decode_fast")                // JA      _decode_fast
-        self.Emit("BTQ"    , _AX, _DX)                      // BTQ     _AX, _DX
-        self.Sjmp("JNC"    , "_decode_fast")                // JNC     _decode_fast
-        self.Emit("ADDQ"   , jit.Imm(1), _IC)               // ADDQ    $1, IC
-    }
-
-    /* at least 4 spaces */
-    self.Emit("CMPQ"   , _IC, _IL)                      // CMPQ    IC, IL
-    self.Sjmp("JAE"    , "_decode_V_EOF")               // JAE     _decode_V_EOF
-    self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX)  // MOVBQZX (IP)(IC), AX
-
-    /* fast path: use lookup table to select decoder */
-    self.Link("_decode_fast")                           // _decode_fast:
-    self.Byte(0x48, 0x8d, 0x3d)                         // LEAQ    ?(PC), DI
-    self.Sref("_decode_tab", 4)                         // ....    &_decode_tab
-    self.Emit("MOVLQSX", jit.Sib(_DI, _AX, 4, 0), _AX)  // MOVLQSX (DI)(AX*4), AX
-    self.Emit("TESTQ"  , _AX, _AX)                      // TESTQ   AX, AX
-    self.Sjmp("JZ"     , "_decode_native")              // JZ      _decode_native
-    self.Emit("ADDQ"   , jit.Imm(1), _IC)               // ADDQ    $1, IC
-    self.Emit("ADDQ"   , _DI, _AX)                      // ADDQ    DI, AX
-    self.Rjmp("JMP"    , _AX)                           // JMP     AX
-
-    /* decode with native decoder */
-    self.Link("_decode_native")         // _decode_native:
-    self.Emit("MOVQ", _IP, _DI)         // MOVQ IP, DI
-    self.Emit("MOVQ", _IL, _SI)         // MOVQ IL, SI
-    self.Emit("MOVQ", _IC, _DX)         // MOVQ IC, DX
-    self.Emit("LEAQ", _VAR_ss, _CX)     // LEAQ ss, CX
-    self.Emit("MOVQ", _VAR_df, _R8)     // MOVQ $df, R8
-    self.Emit("BTSQ", jit.Imm(_F_allow_control), _R8)  // ANDQ $1<<_F_allow_control, R8
-    self.call(_F_value)                 // CALL value
-    self.Emit("MOVQ", _AX, _IC)         // MOVQ AX, IC
-
-    /* check for errors */
-    self.Emit("MOVQ" , _VAR_ss_Vt, _AX)     // MOVQ  ss.Vt, AX
-    self.Emit("TESTQ", _AX, _AX)            // TESTQ AX, AX
-    self.Sjmp("JS"   , "_parsing_error")
-    self.Sjmp("JZ"   , "_invalid_vtype")    // JZ    _invalid_vtype
-    self.Emit("CMPQ" , _AX, _V_max)         // CMPQ  AX, _V_max
-    self.Sjmp("JA"   , "_invalid_vtype")    // JA    _invalid_vtype
-
-    /* jump table selector */
-    self.Byte(0x48, 0x8d, 0x3d)                             // LEAQ    ?(PC), DI
-    self.Sref("_switch_table", 4)                           // ....    &_switch_table
-    self.Emit("MOVLQSX", jit.Sib(_DI, _AX, 4, -4), _AX)     // MOVLQSX -4(DI)(AX*4), AX
-    self.Emit("ADDQ"   , _DI, _AX)                          // ADDQ    DI, AX
-    self.Rjmp("JMP"    , _AX)                               // JMP     AX
-
-    /** V_EOF **/
-    self.Link("_decode_V_EOF")          // _decode_V_EOF:
-    self.Emit("MOVL", _E_eof, _EP)      // MOVL _E_eof, EP
-    self.Sjmp("JMP" , "_error")         // JMP  _error
-
-    /** V_NULL **/
-    self.Link("_decode_V_NULL")                 // _decode_V_NULL:
-    self.Emit("XORL", _R8, _R8)                 // XORL R8, R8
-    self.Emit("XORL", _R9, _R9)                 // XORL R9, R9
-    self.Emit("LEAQ", jit.Ptr(_IC, -4), _DI)    // LEAQ -4(IC), DI
-    self.Sjmp("JMP" , "_set_value")             // JMP  _set_value
-
-    /** V_TRUE **/
-    self.Link("_decode_V_TRUE")                 // _decode_V_TRUE:
-    self.Emit("MOVQ", _T_bool, _R8)             // MOVQ _T_bool, R8
-    // TODO: maybe modified by users?
-    self.Emit("MOVQ", _V_true, _R9)             // MOVQ _V_true, R9 
-    self.Emit("LEAQ", jit.Ptr(_IC, -4), _DI)    // LEAQ -4(IC), DI
-    self.Sjmp("JMP" , "_set_value")             // JMP  _set_value
-
-    /** V_FALSE **/
-    self.Link("_decode_V_FALSE")                // _decode_V_FALSE:
-    self.Emit("MOVQ", _T_bool, _R8)             // MOVQ _T_bool, R8
-    self.Emit("MOVQ", _V_false, _R9)            // MOVQ _V_false, R9
-    self.Emit("LEAQ", jit.Ptr(_IC, -5), _DI)    // LEAQ -5(IC), DI
-    self.Sjmp("JMP" , "_set_value")             // JMP  _set_value
-
-    /** V_ARRAY **/
-    self.Link("_decode_V_ARRAY")                            // _decode_V_ARRAY
-    self.Emit("MOVL", jit.Imm(_S_vmask), _DX)               // MOVL _S_vmask, DX
-    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
-    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)    // MOVQ ST.Vt[CX], AX
-    self.Emit("BTQ" , _AX, _DX)                             // BTQ  AX, DX
-    self.Sjmp("JNC" , "_invalid_char")                      // JNC  _invalid_char
-
-    /* create a new array */
-    self.Emit("MOVQ", _T_eface, _AX)                            // MOVQ    _T_eface, AX
-    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 0))                     // MOVQ    AX, (SP)
-    self.Emit("MOVQ", jit.Imm(_A_init_len), jit.Ptr(_SP, 8))    // MOVQ    _A_init_len, 8(SP)
-    self.Emit("MOVQ", jit.Imm(_A_init_cap), jit.Ptr(_SP, 16))   // MOVQ    _A_init_cap, 16(SP)
-    self.call_go(_F_makeslice)                                  // CALL_GO runtime.makeslice
-    self.Emit("MOVQ", jit.Ptr(_SP, 24), _DX)                    // MOVQ    24(SP), DX
-
-    /* pack into an interface */
-    self.Emit("MOVQ", _DX, jit.Ptr(_SP, 0))                     // MOVQ    DX, (SP)
-    self.Emit("MOVQ", jit.Imm(_A_init_len), jit.Ptr(_SP, 8))    // MOVQ    _A_init_len, 8(SP)
-    self.Emit("MOVQ", jit.Imm(_A_init_cap), jit.Ptr(_SP, 16))   // MOVQ    _A_init_cap, 16(SP)
-    self.call_go(_F_convTslice)                                 // CALL_GO runtime.convTslice
-    self.Emit("MOVQ", jit.Ptr(_SP, 24), _R8)                    // MOVQ    24(SP), R8
-
-    /* replace current state with an array */
-    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                        // MOVQ ST.Sp, CX
-    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)                // MOVQ ST.Vp[CX], SI
-    self.Emit("MOVQ", jit.Imm(_S_arr), jit.Sib(_ST, _CX, 8, _ST_Vt))    // MOVQ _S_arr, ST.Vt[CX]
-    self.Emit("MOVQ", _T_slice, _AX)                                    // MOVQ _T_slice, AX
-    self.Emit("MOVQ", _AX, jit.Ptr(_SI, 0))                             // MOVQ AX, (SI)
-    self.WriteRecNotAX(2, _R8, jit.Ptr(_SI, 8), false)                            // MOVQ R8, 8(SI)
-
-    /* add a new slot for the first element */
-    self.Emit("ADDQ", jit.Imm(1), _CX)                                  // ADDQ $1, CX
-    self.Emit("CMPQ", _CX, jit.Imm(types.MAX_RECURSE))                  // CMPQ CX, ${types.MAX_RECURSE}
-    self.Sjmp("JAE"  , "_stack_overflow")                                // JA   _stack_overflow
-    self.Emit("MOVQ", jit.Ptr(_R8, 0), _AX)                             // MOVQ (R8), AX
-    self.Emit("MOVQ", _CX, jit.Ptr(_ST, _ST_Sp))                        // MOVQ CX, ST.Sp
-    self.WritePtrAX(3, jit.Sib(_ST, _CX, 8, _ST_Vp), false)                // MOVQ AX, ST.Vp[CX]
-    self.Emit("MOVQ", jit.Imm(_S_arr_0), jit.Sib(_ST, _CX, 8, _ST_Vt))  // MOVQ _S_arr_0, ST.Vt[CX]
-    self.Sjmp("JMP" , "_next")                                          // JMP  _next
-
-    /** V_OBJECT **/
-    self.Link("_decode_V_OBJECT")                                       // _decode_V_OBJECT:
-    self.Emit("MOVL", jit.Imm(_S_vmask), _DX)                           // MOVL    _S_vmask, DX
-    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                        // MOVQ    ST.Sp, CX
-    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)                // MOVQ    ST.Vt[CX], AX
-    self.Emit("BTQ" , _AX, _DX)                                         // BTQ     AX, DX
-    self.Sjmp("JNC" , "_invalid_char")                                  // JNC     _invalid_char
-    self.call_go(_F_makemap_small)                                      // CALL_GO runtime.makemap_small
-    self.Emit("MOVQ", jit.Ptr(_SP, 0), _AX)                             // MOVQ    (SP), AX
-    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                        // MOVQ    ST.Sp, CX
-    self.Emit("MOVQ", jit.Imm(_S_obj_0), jit.Sib(_ST, _CX, 8, _ST_Vt))    // MOVQ    _S_obj, ST.Vt[CX]
-    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)                // MOVQ    ST.Vp[CX], SI
-    self.Emit("MOVQ", _T_map, _DX)                                      // MOVQ    _T_map, DX
-    self.Emit("MOVQ", _DX, jit.Ptr(_SI, 0))                             // MOVQ    DX, (SI)
-    self.WritePtrAX(4, jit.Ptr(_SI, 8), false)                             // MOVQ    AX, 8(SI)
-    self.Sjmp("JMP" , "_next")                                          // JMP     _next
-
-    /** V_STRING **/
-    self.Link("_decode_V_STRING")       // _decode_V_STRING:
-    self.Emit("MOVQ", _VAR_ss_Iv, _CX)  // MOVQ ss.Iv, CX
-    self.Emit("MOVQ", _IC, _AX)         // MOVQ IC, AX
-    self.Emit("SUBQ", _CX, _AX)         // SUBQ CX, AX
-
-    /* check for escapes */
-    self.Emit("CMPQ", _VAR_ss_Ep, jit.Imm(-1))          // CMPQ ss.Ep, $-1
-    self.Sjmp("JNE" , "_unquote")                       // JNE  _unquote
-    self.Emit("SUBQ", jit.Imm(1), _AX)                  // SUBQ $1, AX
-    self.Emit("LEAQ", jit.Sib(_IP, _CX, 1, 0), _R8)     // LEAQ (IP)(CX), R8
-    self.Byte(0x48, 0x8d, 0x3d)                         // LEAQ (PC), DI
-    self.Sref("_copy_string_end", 4)
-    self.Emit("BTQ", jit.Imm(_F_copy_string), _VAR_df)
-    self.Sjmp("JC", "copy_string")
-    self.Link("_copy_string_end")                                 
-    self.Emit("XORL", _DX, _DX)                             // XORL DX, DX
-    /* strings with no escape sequences */
-    self.Link("_noescape")                                  // _noescape:
-    self.Emit("MOVL", jit.Imm(_S_omask_key), _DI)               // MOVL _S_omask, DI
-    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
-    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _SI)    // MOVQ ST.Vt[CX], SI
-    self.Emit("BTQ" , _SI, _DI)                             // BTQ  SI, DI
-    self.Sjmp("JC"  , "_object_key")                        // JC   _object_key
-
-    /* check for pre-packed strings, avoid 1 allocation */
-    self.Emit("TESTQ", _DX, _DX)                // TESTQ   DX, DX
-    self.Sjmp("JNZ"  , "_packed_str")           // JNZ     _packed_str
-    self.Emit("MOVQ" , _R8, jit.Ptr(_SP, 0))    // MOVQ    R8, (SP)
-    self.Emit("MOVQ" , _AX, jit.Ptr(_SP, 8))    // MOVQ    AX, 8(SP)
-    self.call_go(_F_convTstring)                // CALL_GO runtime.convTstring
-    self.Emit("MOVQ" , jit.Ptr(_SP, 16), _R9)   // MOVQ    16(SP), R9
-
-    /* packed string already in R9 */
-    self.Link("_packed_str")            // _packed_str:
-    self.Emit("MOVQ", _T_string, _R8)   // MOVQ _T_string, R8
-    self.Emit("MOVQ", _VAR_ss_Iv, _DI)  // MOVQ ss.Iv, DI
-    self.Emit("SUBQ", jit.Imm(1), _DI)  // SUBQ $1, DI
-    self.Sjmp("JMP" , "_set_value")     // JMP  _set_value
-
-    /* the string is an object key, get the map */
-    self.Link("_object_key")
-    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
-    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)    // MOVQ ST.Vp[CX], SI
-    self.Emit("MOVQ", jit.Ptr(_SI, 8), _SI)                 // MOVQ 8(SI), SI
-
-    /* add a new delimiter */
-    self.Emit("ADDQ", jit.Imm(1), _CX)                                      // ADDQ $1, CX
-    self.Emit("CMPQ", _CX, jit.Imm(types.MAX_RECURSE))                      // CMPQ CX, ${types.MAX_RECURSE}
-    self.Sjmp("JAE"  , "_stack_overflow")                                    // JA   _stack_overflow
-    self.Emit("MOVQ", _CX, jit.Ptr(_ST, _ST_Sp))                            // MOVQ CX, ST.Sp
-    self.Emit("MOVQ", jit.Imm(_S_obj_delim), jit.Sib(_ST, _CX, 8, _ST_Vt))  // MOVQ _S_obj_delim, ST.Vt[CX]
-
-    /* add a new slot int the map */
-    self.Emit("MOVQ", _T_map, _DX)                      // MOVQ    _T_map, DX
-    self.Emit("MOVQ", _DX, jit.Ptr(_SP, 0))             // MOVQ    DX, (SP)
-    self.Emit("MOVQ", _SI, jit.Ptr(_SP, 8))             // MOVQ    SI, 8(SP)
-    self.Emit("MOVQ", _R8, jit.Ptr(_SP, 16))            // MOVQ    R9, 16(SP)
-    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 24))            // MOVQ    AX, 24(SP)
-    self.call_go(_F_mapassign_faststr)                  // CALL_GO runtime.mapassign_faststr
-    self.Emit("MOVQ", jit.Ptr(_SP, 32), _AX)            // MOVQ    32(SP), AX
-
-    /* add to the pointer stack */
-    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                 // MOVQ ST.Sp, CX
-    self.WritePtrAX(6, jit.Sib(_ST, _CX, 8, _ST_Vp), false)    // MOVQ AX, ST.Vp[CX]
-    self.Sjmp("JMP" , "_next")                                   // JMP  _next
-
-    /* allocate memory to store the string header and unquoted result */
-    self.Link("_unquote")                               // _unquote:
-    self.Emit("ADDQ", jit.Imm(15), _AX)                 // ADDQ    $15, AX
-    self.Emit("MOVQ", _T_byte, _CX)                     // MOVQ    _T_byte, CX
-    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 0))             // MOVQ    AX, (SP)
-    self.Emit("MOVQ", _CX, jit.Ptr(_SP, 8))             // MOVQ    CX, 8(SP)
-    self.Emit("MOVB", jit.Imm(0), jit.Ptr(_SP, 16))     // MOVB    $0, 16(SP)
-    self.call_go(_F_mallocgc)                           // CALL_GO runtime.mallocgc
-    self.Emit("MOVQ", jit.Ptr(_SP, 24), _R9)            // MOVQ    24(SP), R9
-
-    /* prepare the unquoting parameters */
-    self.Emit("MOVQ" , _VAR_ss_Iv, _CX)                         // MOVQ  ss.Iv, CX
-    self.Emit("LEAQ" , jit.Sib(_IP, _CX, 1, 0), _DI)            // LEAQ  (IP)(CX), DI
-    self.Emit("NEGQ" , _CX)                                     // NEGQ  CX
-    self.Emit("LEAQ" , jit.Sib(_IC, _CX, 1, -1), _SI)           // LEAQ  -1(IC)(CX), SI
-    self.Emit("LEAQ" , jit.Ptr(_R9, 16), _DX)                   // LEAQ  16(R8), DX
-    self.Emit("LEAQ" , _VAR_ss_Ep, _CX)                         // LEAQ  ss.Ep, CX
-    self.Emit("XORL" , _R8, _R8)                                // XORL  R8, R8
-    self.Emit("BTQ"  , jit.Imm(_F_disable_urc), _VAR_df)        // BTQ   ${_F_disable_urc}, fv
-    self.Emit("SETCC", _R8)                                     // SETCC R8
-    self.Emit("SHLQ" , jit.Imm(types.B_UNICODE_REPLACE), _R8)   // SHLQ  ${types.B_UNICODE_REPLACE}, R8
-
-    /* unquote the string, with R9 been preserved */
-    self.save(_R9)                                      // SAVE R9
-    self.call(_F_unquote)                               // CALL unquote
-    self.load(_R9)                                      // LOAD R9
-
-    /* check for errors */
-    self.Emit("TESTQ", _AX, _AX)                // TESTQ AX, AX
-    self.Sjmp("JS"   , "_unquote_error")        // JS    _unquote_error
-    self.Emit("MOVL" , jit.Imm(1), _DX)         // MOVL  $1, DX
-    self.Emit("LEAQ" , jit.Ptr(_R9, 16), _R8)   // ADDQ  $16, R8
-    self.Emit("MOVQ" , _R8, jit.Ptr(_R9, 0))    // MOVQ  R8, (R9)
-    self.Emit("MOVQ" , _AX, jit.Ptr(_R9, 8))    // MOVQ  AX, 8(R9)
-    self.Sjmp("JMP"  , "_noescape")             // JMP   _noescape
-
-    /** V_DOUBLE **/
-    self.Link("_decode_V_DOUBLE")                           // _decode_V_DOUBLE:
-    self.Emit("BTQ"  , jit.Imm(_F_use_number), _VAR_df)     // BTQ     _F_use_number, df
-    self.Sjmp("JC"   , "_use_number")                       // JC      _use_number
-    self.Emit("MOVSD", _VAR_ss_Dv, _X0)                     // MOVSD   ss.Dv, X0
-    self.Sjmp("JMP"  , "_use_float64")                      // JMP     _use_float64
-
-    /** V_INTEGER **/
-    self.Link("_decode_V_INTEGER")                          // _decode_V_INTEGER:
-    self.Emit("BTQ"     , jit.Imm(_F_use_number), _VAR_df)  // BTQ      _F_use_number, df
-    self.Sjmp("JC"      , "_use_number")                    // JC       _use_number
-    self.Emit("BTQ"     , jit.Imm(_F_use_int64), _VAR_df)   // BTQ      _F_use_int64, df
-    self.Sjmp("JC"      , "_use_int64")                     // JC       _use_int64
-    self.Emit("MOVQ"    , _VAR_ss_Iv, _AX)                  // MOVQ     ss.Iv, AX
-    self.Emit("CVTSQ2SD", _AX, _X0)                         // CVTSQ2SD AX, X0
-
-    /* represent numbers as `float64` */
-    self.Link("_use_float64")                   // _use_float64:
-    self.Emit("MOVSD", _X0, jit.Ptr(_SP, 0))    // MOVSD   X0, (SP)
-    self.call_go(_F_convT64)                    // CALL_GO runtime.convT64
-    self.Emit("MOVQ" , _T_float64, _R8)         // MOVQ    _T_float64, R8
-    self.Emit("MOVQ" , jit.Ptr(_SP, 8), _R9)    // MOVQ    8(SP), R9
-    self.Emit("MOVQ" , _VAR_ss_Ep, _DI)         // MOVQ    ss.Ep, DI
-    self.Sjmp("JMP"  , "_set_value")            // JMP     _set_value
-
-    /* represent numbers as `json.Number` */
-    self.Link("_use_number")                            // _use_number
-    self.Emit("MOVQ", _VAR_ss_Ep, _AX)                  // MOVQ    ss.Ep, AX
-    self.Emit("LEAQ", jit.Sib(_IP, _AX, 1, 0), _SI)     // LEAQ    (IP)(AX), SI
-    self.Emit("MOVQ", _IC, _CX)                         // MOVQ    IC, CX
-    self.Emit("SUBQ", _AX, _CX)                         // SUBQ    AX, CX
-    self.Emit("MOVQ", _SI, jit.Ptr(_SP, 0))             // MOVQ    SI, (SP)
-    self.Emit("MOVQ", _CX, jit.Ptr(_SP, 8))             // MOVQ    CX, 8(SP)
-    self.call_go(_F_convTstring)                        // CALL_GO runtime.convTstring
-    self.Emit("MOVQ", _T_number, _R8)                   // MOVQ    _T_number, R8
-    self.Emit("MOVQ", jit.Ptr(_SP, 16), _R9)            // MOVQ    16(SP), R9
-    self.Emit("MOVQ", _VAR_ss_Ep, _DI)                  // MOVQ    ss.Ep, DI
-    self.Sjmp("JMP" , "_set_value")                     // JMP     _set_value
-
-    /* represent numbers as `int64` */
-    self.Link("_use_int64")                     // _use_int64:
-    self.Emit("MOVQ", _VAR_ss_Iv, _AX)          // MOVQ    ss.Iv, AX
-    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 0))     // MOVQ    AX, (SP)
-    self.call_go(_F_convT64)                    // CALL_GO runtime.convT64
-    self.Emit("MOVQ", _T_int64, _R8)            // MOVQ    _T_int64, R8
-    self.Emit("MOVQ", jit.Ptr(_SP, 8), _R9)     // MOVQ    8(SP), R9
-    self.Emit("MOVQ", _VAR_ss_Ep, _DI)          // MOVQ    ss.Ep, DI
-    self.Sjmp("JMP" , "_set_value")             // JMP     _set_value
-
-    /** V_KEY_SEP **/
-    self.Link("_decode_V_KEY_SEP")                                          // _decode_V_KEY_SEP:
-    // self.Byte(0xcc)
-    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                            // MOVQ ST.Sp, CX
-    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)                    // MOVQ ST.Vt[CX], AX
-    self.Emit("CMPQ", _AX, jit.Imm(_S_obj_delim))                           // CMPQ AX, _S_obj_delim
-    self.Sjmp("JNE" , "_invalid_char")                                      // JNE  _invalid_char
-    self.Emit("MOVQ", jit.Imm(_S_val), jit.Sib(_ST, _CX, 8, _ST_Vt))        // MOVQ _S_val, ST.Vt[CX]
-    self.Emit("MOVQ", jit.Imm(_S_obj), jit.Sib(_ST, _CX, 8, _ST_Vt - 8))    // MOVQ _S_obj, ST.Vt[CX - 1]
-    self.Sjmp("JMP" , "_next")                                              // JMP  _next
-
-    /** V_ELEM_SEP **/
-    self.Link("_decode_V_ELEM_SEP")                             // _decode_V_ELEM_SEP:
-    self.Emit("MOVQ" , jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ     ST.Sp, CX
-    self.Emit("MOVQ" , jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)    // MOVQ     ST.Vt[CX], AX
-    self.Emit("CMPQ" , _AX, jit.Imm(_S_arr))                 // CMPQ     _AX, _S_arr
-    self.Sjmp("JE"   , "_array_sep")                         // JZ       _next
-    self.Emit("CMPQ" , _AX, jit.Imm(_S_obj))                 // CMPQ     _AX, _S_arr
-    self.Sjmp("JNE"  , "_invalid_char")                      // JNE      _invalid_char
-    self.Emit("MOVQ" , jit.Imm(_S_obj_sep), jit.Sib(_ST, _CX, 8, _ST_Vt))
-    self.Sjmp("JMP"  , "_next")                              // JMP      _next
-
-    /* arrays */
-    self.Link("_array_sep")
-    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)    // MOVQ ST.Vp[CX], SI
-    self.Emit("MOVQ", jit.Ptr(_SI, 8), _SI)                 // MOVQ 8(SI), SI
-    self.Emit("MOVQ", jit.Ptr(_SI, 8), _DX)                 // MOVQ 8(SI), DX
-    self.Emit("CMPQ", _DX, jit.Ptr(_SI, 16))                // CMPQ DX, 16(SI)
-    self.Sjmp("JAE" , "_array_more")                        // JAE  _array_more
-
-    /* add a slot for the new element */
-    self.Link("_array_append")                                          // _array_append:
-    self.Emit("ADDQ", jit.Imm(1), jit.Ptr(_SI, 8))                      // ADDQ $1, 8(SI)
-    self.Emit("MOVQ", jit.Ptr(_SI, 0), _SI)                             // MOVQ (SI), SI
-    self.Emit("ADDQ", jit.Imm(1), _CX)                                  // ADDQ $1, CX
-    self.Emit("CMPQ", _CX, jit.Imm(types.MAX_RECURSE))                  // CMPQ CX, ${types.MAX_RECURSE}
-    self.Sjmp("JAE"  , "_stack_overflow") 
-    self.Emit("SHLQ", jit.Imm(1), _DX)                                  // SHLQ $1, DX
-    self.Emit("LEAQ", jit.Sib(_SI, _DX, 8, 0), _SI)                     // LEAQ (SI)(DX*8), SI
-    self.Emit("MOVQ", _CX, jit.Ptr(_ST, _ST_Sp))                        // MOVQ CX, ST.Sp
-    self.WriteRecNotAX(7 , _SI, jit.Sib(_ST, _CX, 8, _ST_Vp), false)           // MOVQ SI, ST.Vp[CX]
-    self.Emit("MOVQ", jit.Imm(_S_val), jit.Sib(_ST, _CX, 8, _ST_Vt))    // MOVQ _S_val, ST.Vt[CX}
-    self.Sjmp("JMP" , "_next")                                          // JMP  _next
-
-    /** V_ARRAY_END **/
-    self.Link("_decode_V_ARRAY_END")                        // _decode_V_ARRAY_END:
-    self.Emit("XORL", _DX, _DX)                             // XORL DX, DX
-    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
-    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)    // MOVQ ST.Vt[CX], AX
-    self.Emit("CMPQ", _AX, jit.Imm(_S_arr_0))               // CMPQ AX, _S_arr_0
-    self.Sjmp("JE"  , "_first_item")                        // JE   _first_item
-    self.Emit("CMPQ", _AX, jit.Imm(_S_arr))                 // CMPQ AX, _S_arr
-    self.Sjmp("JNE" , "_invalid_char")                      // JNE  _invalid_char
-    self.Emit("SUBQ", jit.Imm(1), jit.Ptr(_ST, _ST_Sp))     // SUBQ $1, ST.Sp
-    self.Emit("MOVQ", _DX, jit.Sib(_ST, _CX, 8, _ST_Vp))    // MOVQ DX, ST.Vp[CX]
-    self.Sjmp("JMP" , "_next")                              // JMP  _next
-
-    /* first element of an array */
-    self.Link("_first_item")                                    // _first_item:
-    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                // MOVQ ST.Sp, CX
-    self.Emit("SUBQ", jit.Imm(2), jit.Ptr(_ST, _ST_Sp))         // SUBQ $2, ST.Sp
-    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp - 8), _SI)    // MOVQ ST.Vp[CX - 1], SI
-    self.Emit("MOVQ", jit.Ptr(_SI, 8), _SI)                     // MOVQ 8(SI), SI
-    self.Emit("MOVQ", _DX, jit.Sib(_ST, _CX, 8, _ST_Vp - 8))    // MOVQ DX, ST.Vp[CX - 1]
-    self.Emit("MOVQ", _DX, jit.Sib(_ST, _CX, 8, _ST_Vp))        // MOVQ DX, ST.Vp[CX]
-    self.Emit("MOVQ", _DX, jit.Ptr(_SI, 8))                     // MOVQ DX, 8(SI)
-    self.Sjmp("JMP" , "_next")                                  // JMP  _next
-
-    /** V_OBJECT_END **/
-    self.Link("_decode_V_OBJECT_END")                       // _decode_V_OBJECT_END:
-    self.Emit("MOVL", jit.Imm(_S_omask_end), _DX)           // MOVL _S_omask, DI
-    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
-    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)    // MOVQ ST.Vt[CX], AX
-    self.Emit("BTQ" , _AX, _DX)                
-    self.Sjmp("JNC" , "_invalid_char")                      // JNE  _invalid_char
-    self.Emit("XORL", _AX, _AX)                             // XORL AX, AX
-    self.Emit("SUBQ", jit.Imm(1), jit.Ptr(_ST, _ST_Sp))     // SUBQ $1, ST.Sp
-    self.Emit("MOVQ", _AX, jit.Sib(_ST, _CX, 8, _ST_Vp))    // MOVQ AX, ST.Vp[CX]
-    self.Sjmp("JMP" , "_next")                              // JMP  _next
-
-    /* return from decoder */
-    self.Link("_return")                            // _return:
-    self.Emit("XORL", _EP, _EP)                     // XORL EP, EP
-    self.Emit("MOVQ", _EP, jit.Ptr(_ST, _ST_Vp))    // MOVQ EP, ST.Vp[0]
-    self.Link("_epilogue")                          // _epilogue:
-    self.Emit("SUBQ", jit.Imm(_FsmOffset), _ST)     // SUBQ _FsmOffset, _ST
-    self.Emit("MOVQ", jit.Ptr(_SP, _VD_offs), _BP)  // MOVQ _VD_offs(SP), BP
-    self.Emit("ADDQ", jit.Imm(_VD_size), _SP)       // ADDQ $_VD_size, SP
-    self.Emit("RET")                                // RET
-
-    /* array expand */
-    self.Link("_array_more")                    // _array_more:
-    self.Emit("MOVQ" , _T_eface, _AX)           // MOVQ    _T_eface, AX
-    self.Emit("MOVOU", jit.Ptr(_SI, 0), _X0)    // MOVOU   (SI), X0
-    self.Emit("MOVQ" , jit.Ptr(_SI, 16), _DX)   // MOVQ    16(SI), DX
-    self.Emit("MOVQ" , _AX, jit.Ptr(_SP, 0))    // MOVQ    AX, (SP)
-    self.Emit("MOVOU", _X0, jit.Ptr(_SP, 8))    // MOVOU   X0, 8(SP)
-    self.Emit("MOVQ" , _DX, jit.Ptr(_SP, 24))   // MOVQ    DX, 24(SP)
-    self.Emit("SHLQ" , jit.Imm(1), _DX)         // SHLQ    $1, DX
-    self.Emit("MOVQ" , _DX, jit.Ptr(_SP, 32))   // MOVQ    DX, 32(SP)
-    self.call_go(_F_growslice)                  // CALL_GO runtime.growslice
-    self.Emit("MOVQ" , jit.Ptr(_SP, 40), _DI)   // MOVOU   40(SP), DI
-    self.Emit("MOVQ" , jit.Ptr(_SP, 48), _DX)   // MOVOU   48(SP), DX
-    self.Emit("MOVQ" , jit.Ptr(_SP, 56), _AX)   // MOVQ    56(SP), AX
-
-    /* update the slice */
-    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
-    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)    // MOVQ ST.Vp[CX], SI
-    self.Emit("MOVQ", jit.Ptr(_SI, 8), _SI)                 // MOVQ 8(SI), SI
-    self.Emit("MOVQ", _DX, jit.Ptr(_SI, 8))                 // MOVQ DX, 8(SI)
-    self.Emit("MOVQ", _AX, jit.Ptr(_SI, 16))                // MOVQ AX, 16(AX)
-    self.WriteRecNotAX(8 , _DI, jit.Ptr(_SI, 0), false)                 // MOVQ R10, (SI)
-    self.Sjmp("JMP" , "_array_append")                      // JMP  _array_append
-
-    /* copy string */
-    self.Link("copy_string")  // pointer: R8, length: AX, return addr: DI
-    // self.Byte(0xcc)
-    self.Emit("MOVQ", _R8, _VAR_cs_p)
-    self.Emit("MOVQ", _AX, _VAR_cs_n)
-    self.Emit("MOVQ", _DI, _VAR_cs_LR)
-    self.Emit("MOVQ", _T_byte, jit.Ptr(_SP, 0))
-    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 8))
-    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 16))
-    self.call_go(_F_makeslice)                              
-    self.Emit("MOVQ", jit.Ptr(_SP, 24), _R8)      
-    self.Emit("MOVQ", _R8, _VAR_cs_d)                    
-    self.Emit("MOVQ", _R8, jit.Ptr(_SP, 0))                    
-    self.Emit("MOVQ", _VAR_cs_p, _R8)
-    self.Emit("MOVQ", _R8, jit.Ptr(_SP, 8))
-    self.Emit("MOVQ", _VAR_cs_n, _AX)
-    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 16))
-    self.call_go(_F_memmove)
-    self.Emit("MOVQ", _VAR_cs_d, _R8)
-    self.Emit("MOVQ", _VAR_cs_n, _AX)
-    self.Emit("MOVQ", _VAR_cs_LR, _DI)
-    // self.Byte(0xcc)
-    self.Rjmp("JMP", _DI)
-
-    /* error handlers */
-    self.Link("_stack_overflow")
-    self.Emit("MOVL" , _E_recurse, _EP)         // MOVQ  _E_recurse, EP
-    self.Sjmp("JMP"  , "_error")                // JMP   _error
-    self.Link("_vtype_error")                   // _vtype_error:
-    self.Emit("MOVQ" , _DI, _IC)                // MOVQ  DI, IC
-    self.Emit("MOVL" , _E_invalid, _EP)         // MOVL  _E_invalid, EP
-    self.Sjmp("JMP"  , "_error")                // JMP   _error
-    self.Link("_invalid_char")                  // _invalid_char:
-    self.Emit("SUBQ" , jit.Imm(1), _IC)         // SUBQ  $1, IC
-    self.Emit("MOVL" , _E_invalid, _EP)         // MOVL  _E_invalid, EP
-    self.Sjmp("JMP"  , "_error")                // JMP   _error
-    self.Link("_unquote_error")                 // _unquote_error:
-    self.Emit("MOVQ" , _VAR_ss_Iv, _IC)         // MOVQ  ss.Iv, IC
-    self.Emit("SUBQ" , jit.Imm(1), _IC)         // SUBQ  $1, IC
-    self.Link("_parsing_error")                 // _parsing_error:
-    self.Emit("NEGQ" , _AX)                     // NEGQ  AX
-    self.Emit("MOVQ" , _AX, _EP)                // MOVQ  AX, EP
-    self.Link("_error")                         // _error:
-    self.Emit("PXOR" , _X0, _X0)                // PXOR  X0, X0
-    self.Emit("MOVOU", _X0, jit.Ptr(_VP, 0))    // MOVOU X0, (VP)
-    self.Sjmp("JMP"  , "_epilogue")             // JMP   _epilogue
-
-    /* invalid value type, never returns */
-    self.Link("_invalid_vtype")
-    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 0))     // MOVQ AX, (SP)
-    self.call(_F_invalid_vtype)                 // CALL invalid_type
-    self.Emit("UD2")                            // UD2
-
-    /* switch jump table */
-    self.Link("_switch_table")              // _switch_table:
-    self.Sref("_decode_V_EOF", 0)           // SREF &_decode_V_EOF, $0
-    self.Sref("_decode_V_NULL", -4)         // SREF &_decode_V_NULL, $-4
-    self.Sref("_decode_V_TRUE", -8)         // SREF &_decode_V_TRUE, $-8
-    self.Sref("_decode_V_FALSE", -12)       // SREF &_decode_V_FALSE, $-12
-    self.Sref("_decode_V_ARRAY", -16)       // SREF &_decode_V_ARRAY, $-16
-    self.Sref("_decode_V_OBJECT", -20)      // SREF &_decode_V_OBJECT, $-20
-    self.Sref("_decode_V_STRING", -24)      // SREF &_decode_V_STRING, $-24
-    self.Sref("_decode_V_DOUBLE", -28)      // SREF &_decode_V_DOUBLE, $-28
-    self.Sref("_decode_V_INTEGER", -32)     // SREF &_decode_V_INTEGER, $-32
-    self.Sref("_decode_V_KEY_SEP", -36)     // SREF &_decode_V_KEY_SEP, $-36
-    self.Sref("_decode_V_ELEM_SEP", -40)    // SREF &_decode_V_ELEM_SEP, $-40
-    self.Sref("_decode_V_ARRAY_END", -44)   // SREF &_decode_V_ARRAY_END, $-44
-    self.Sref("_decode_V_OBJECT_END", -48)  // SREF &_decode_V_OBJECT_END, $-48
-
-    /* fast character lookup table */
-    self.Link("_decode_tab")        // _decode_tab:
-    self.Sref("_decode_V_EOF", 0)   // SREF &_decode_V_EOF, $0
-
-    /* generate rest of the tabs */
-    for i := 1; i < 256; i++ {
-        if to, ok := _R_tab[i]; ok {
-            self.Sref(to, -int64(i) * 4)
-        } else {
-            self.Byte(0x00, 0x00, 0x00, 0x00)
-        }
-    }
-}
-
-func (self *_ValueDecoder) WritePtrAX(i int, rec obj.Addr, saveDI bool) {
-    self.Emit("MOVQ", _V_writeBarrier, _R10)
-    self.Emit("CMPL", jit.Ptr(_R10, 0), jit.Imm(0))
-    self.Sjmp("JE", "_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
-    if saveDI {
-        self.save(_DI)
-    }
-    self.Emit("LEAQ", rec, _DI)
-    self.Emit("MOVQ", _F_gcWriteBarrierAX, _R10)  // MOVQ ${fn}, AX
-    self.Rjmp("CALL", _R10)  
-    if saveDI {
-        self.load(_DI)
-    }    
-    self.Sjmp("JMP", "_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
-    self.Link("_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
-    self.Emit("MOVQ", _AX, rec)
-    self.Link("_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
-}
-
-func (self *_ValueDecoder) WriteRecNotAX(i int, ptr obj.Addr, rec obj.Addr, saveDI bool) {
-    if rec.Reg == x86.REG_AX || rec.Index == x86.REG_AX {
-        panic("rec contains AX!")
-    }
-    self.Emit("MOVQ", _V_writeBarrier, _R10)
-    self.Emit("CMPL", jit.Ptr(_R10, 0), jit.Imm(0))
-    self.Sjmp("JE", "_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
-    self.Emit("MOVQ", ptr, _AX)
-    if saveDI {
-        self.save(_DI)
-    }
-    self.Emit("LEAQ", rec, _DI)
-    self.Emit("MOVQ", _F_gcWriteBarrierAX, _R10)  // MOVQ ${fn}, AX
-    self.Rjmp("CALL", _R10)  
-    if saveDI {
-        self.load(_DI)
-    }    
-    self.Sjmp("JMP", "_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
-    self.Link("_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
-    self.Emit("MOVQ", ptr, rec)
-    self.Link("_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
-}
-
-/** Generic Decoder **/
-
-var (
-    _subr_decode_value = new(_ValueDecoder).build()
-)
-
-//go:nosplit
-func invalid_vtype(vt types.ValueType) {
-    throw(fmt.Sprintf("invalid value type: %d", vt))
-}

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

@@ -1,772 +0,0 @@
-//go:build go1.17 && !go1.21
-// +build go1.17,!go1.21
-
-/*
- * Copyright 2021 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 decoder
-
-import (
-    `encoding/json`
-    `fmt`
-    `reflect`
-    `strconv`
-
-    `github.com/bytedance/sonic/internal/jit`
-    `github.com/bytedance/sonic/internal/native`
-    `github.com/bytedance/sonic/internal/native/types`
-    `github.com/twitchyliquid64/golang-asm/obj`
-    `github.com/twitchyliquid64/golang-asm/obj/x86`
-)
-
-/** Crucial Registers:
- *
- *      ST(R13) && 0(SP) : ro, decoder stack
- *      DF(AX)  : ro, decoder flags
- *      EP(BX) : wo, error pointer
- *      IP(R10) : ro, input pointer
- *      IL(R12) : ro, input length
- *      IC(R11) : rw, input cursor
- *      VP(R15) : ro, value pointer (to an interface{})
- */
-
-const (
-    _VD_args   = 8      // 8 bytes  for passing arguments to this functions
-    _VD_fargs  = 64     // 64 bytes for passing arguments to other Go functions
-    _VD_saves  = 48     // 48 bytes for saving the registers before CALL instructions
-    _VD_locals = 96     // 96 bytes for local variables
-)
-
-const (
-    _VD_offs = _VD_fargs + _VD_saves + _VD_locals
-    _VD_size = _VD_offs + 8     // 8 bytes for the parent frame pointer
-)
-
-var (
-    _VAR_ss = _VAR_ss_Vt
-    _VAR_df = jit.Ptr(_SP, _VD_fargs + _VD_saves)
-)
-
-var (
-    _VAR_ss_Vt = jit.Ptr(_SP, _VD_fargs + _VD_saves + 8)
-    _VAR_ss_Dv = jit.Ptr(_SP, _VD_fargs + _VD_saves + 16)
-    _VAR_ss_Iv = jit.Ptr(_SP, _VD_fargs + _VD_saves + 24)
-    _VAR_ss_Ep = jit.Ptr(_SP, _VD_fargs + _VD_saves + 32)
-    _VAR_ss_Db = jit.Ptr(_SP, _VD_fargs + _VD_saves + 40)
-    _VAR_ss_Dc = jit.Ptr(_SP, _VD_fargs + _VD_saves + 48)
-)
-
-var (
-    _VAR_R9 = jit.Ptr(_SP, _VD_fargs + _VD_saves + 56)
-)
-type _ValueDecoder struct {
-    jit.BaseAssembler
-}
-
-var (
-    _VAR_cs_LR = jit.Ptr(_SP, _VD_fargs + _VD_saves + 64)
-    _VAR_cs_p = jit.Ptr(_SP, _VD_fargs + _VD_saves + 72)
-    _VAR_cs_n = jit.Ptr(_SP, _VD_fargs + _VD_saves + 80)
-    _VAR_cs_d = jit.Ptr(_SP, _VD_fargs + _VD_saves + 88)
-)
-
-func (self *_ValueDecoder) build() uintptr {
-    self.Init(self.compile)
-    return *(*uintptr)(self.Load("decode_value", _VD_size, _VD_args, argPtrs_generic, localPtrs_generic))
-}
-
-/** Function Calling Helpers **/
-
-func (self *_ValueDecoder) save(r ...obj.Addr) {
-    for i, v := range r {
-        if i > _VD_saves / 8 - 1 {
-            panic("too many registers to save")
-        } else {
-            self.Emit("MOVQ", v, jit.Ptr(_SP, _VD_fargs + int64(i) * 8))
-        }
-    }
-}
-
-func (self *_ValueDecoder) load(r ...obj.Addr) {
-    for i, v := range r {
-        if i > _VD_saves / 8 - 1 {
-            panic("too many registers to load")
-        } else {
-            self.Emit("MOVQ", jit.Ptr(_SP, _VD_fargs + int64(i) * 8), v)
-        }
-    }
-}
-
-func (self *_ValueDecoder) call(fn obj.Addr) {
-    self.Emit("MOVQ", fn, _R9)  // MOVQ ${fn}, AX
-    self.Rjmp("CALL", _R9)      // CALL AX
-}
-
-func (self *_ValueDecoder) call_go(fn obj.Addr) {
-    self.save(_REG_go...)   // SAVE $REG_go
-    self.call(fn)           // CALL ${fn}
-    self.load(_REG_go...)   // LOAD $REG_go
-}
-
-func (self *_ValueDecoder) callc(fn obj.Addr) {
-    self.Emit("XCHGQ", _IP, _BP)
-    self.call(fn)
-    self.Emit("XCHGQ", _IP, _BP)
-}
-
-func (self *_ValueDecoder) call_c(fn obj.Addr) {
-    self.Emit("XCHGQ", _IC, _BX)
-    self.callc(fn)
-    self.Emit("XCHGQ", _IC, _BX)
-}
-
-/** Decoder Assembler **/
-
-const (
-    _S_val = iota + 1
-    _S_arr
-    _S_arr_0
-    _S_obj
-    _S_obj_0
-    _S_obj_delim
-    _S_obj_sep
-)
-
-const (
-    _S_omask_key = (1 << _S_obj_0) | (1 << _S_obj_sep)
-    _S_omask_end = (1 << _S_obj_0) | (1 << _S_obj)
-    _S_vmask = (1 << _S_val) | (1 << _S_arr_0)
-)
-
-const (
-    _A_init_len = 1
-    _A_init_cap = 16
-)
-
-const (
-    _ST_Sp = 0
-    _ST_Vt = _PtrBytes
-    _ST_Vp = _PtrBytes * (types.MAX_RECURSE + 1)
-)
-
-var (
-    _V_true  = jit.Imm(int64(pbool(true)))
-    _V_false = jit.Imm(int64(pbool(false)))
-    _F_value = jit.Imm(int64(native.S_value))
-)
-
-var (
-    _V_max     = jit.Imm(int64(types.V_MAX))
-    _E_eof     = jit.Imm(int64(types.ERR_EOF))
-    _E_invalid = jit.Imm(int64(types.ERR_INVALID_CHAR))
-    _E_recurse = jit.Imm(int64(types.ERR_RECURSE_EXCEED_MAX))
-)
-
-var (
-    _F_convTslice    = jit.Func(convTslice)
-    _F_convTstring   = jit.Func(convTstring)
-    _F_invalid_vtype = jit.Func(invalid_vtype)
-)
-
-var (
-    _T_map     = jit.Type(reflect.TypeOf((map[string]interface{})(nil)))
-    _T_bool    = jit.Type(reflect.TypeOf(false))
-    _T_int64   = jit.Type(reflect.TypeOf(int64(0)))
-    _T_eface   = jit.Type(reflect.TypeOf((*interface{})(nil)).Elem())
-    _T_slice   = jit.Type(reflect.TypeOf(([]interface{})(nil)))
-    _T_string  = jit.Type(reflect.TypeOf(""))
-    _T_number  = jit.Type(reflect.TypeOf(json.Number("")))
-    _T_float64 = jit.Type(reflect.TypeOf(float64(0)))
-)
-
-var _R_tab = map[int]string {
-    '[': "_decode_V_ARRAY",
-    '{': "_decode_V_OBJECT",
-    ':': "_decode_V_KEY_SEP",
-    ',': "_decode_V_ELEM_SEP",
-    ']': "_decode_V_ARRAY_END",
-    '}': "_decode_V_OBJECT_END",
-}
-
-func (self *_ValueDecoder) compile() {
-    self.Emit("SUBQ", jit.Imm(_VD_size), _SP)       // SUBQ $_VD_size, SP
-    self.Emit("MOVQ", _BP, jit.Ptr(_SP, _VD_offs))  // MOVQ BP, _VD_offs(SP)
-    self.Emit("LEAQ", jit.Ptr(_SP, _VD_offs), _BP)  // LEAQ _VD_offs(SP), BP
-
-    /* initialize the state machine */
-    self.Emit("XORL", _CX, _CX)                                 // XORL CX, CX
-    self.Emit("MOVQ", _DF, _VAR_df)                             // MOVQ DF, df
-    /* initialize digital buffer first */
-    self.Emit("MOVQ", jit.Imm(_MaxDigitNums), _VAR_ss_Dc)       // MOVQ $_MaxDigitNums, ss.Dcap
-    self.Emit("LEAQ", jit.Ptr(_ST, _DbufOffset), _AX)           // LEAQ _DbufOffset(ST), AX
-    self.Emit("MOVQ", _AX, _VAR_ss_Db)                          // MOVQ AX, ss.Dbuf
-    /* add ST offset */
-    self.Emit("ADDQ", jit.Imm(_FsmOffset), _ST)                 // ADDQ _FsmOffset, _ST
-    self.Emit("MOVQ", _CX, jit.Ptr(_ST, _ST_Sp))                // MOVQ CX, ST.Sp
-    self.WriteRecNotAX(0, _VP, jit.Ptr(_ST, _ST_Vp), false)                // MOVQ VP, ST.Vp[0]
-    self.Emit("MOVQ", jit.Imm(_S_val), jit.Ptr(_ST, _ST_Vt))    // MOVQ _S_val, ST.Vt[0]
-    self.Sjmp("JMP" , "_next")                                  // JMP  _next
-
-    /* set the value from previous round */
-    self.Link("_set_value")                                 // _set_value:
-    self.Emit("MOVL" , jit.Imm(_S_vmask), _DX)              // MOVL  _S_vmask, DX
-    self.Emit("MOVQ" , jit.Ptr(_ST, _ST_Sp), _CX)           // MOVQ  ST.Sp, CX
-    self.Emit("MOVQ" , jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)   // MOVQ  ST.Vt[CX], AX
-    self.Emit("BTQ"  , _AX, _DX)                            // BTQ   AX, DX
-    self.Sjmp("JNC"  , "_vtype_error")                      // JNC   _vtype_error
-    self.Emit("XORL" , _SI, _SI)                            // XORL  SI, SI
-    self.Emit("SUBQ" , jit.Imm(1), jit.Ptr(_ST, _ST_Sp))    // SUBQ  $1, ST.Sp
-    self.Emit("XCHGQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)   // XCHGQ ST.Vp[CX], SI
-    self.Emit("MOVQ" , _R8, jit.Ptr(_SI, 0))                // MOVQ  R8, (SI)
-    self.WriteRecNotAX(1, _R9, jit.Ptr(_SI, 8), false)           // MOVQ  R9, 8(SI)
-
-    /* check for value stack */
-    self.Link("_next")                              // _next:
-    self.Emit("MOVQ" , jit.Ptr(_ST, _ST_Sp), _AX)   // MOVQ  ST.Sp, AX
-    self.Emit("TESTQ", _AX, _AX)                    // TESTQ AX, AX
-    self.Sjmp("JS"   , "_return")                   // JS    _return
-
-    /* fast path: test up to 4 characters manually */
-    self.Emit("CMPQ"   , _IC, _IL)                      // CMPQ    IC, IL
-    self.Sjmp("JAE"    , "_decode_V_EOF")               // JAE     _decode_V_EOF
-    self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX)  // MOVBQZX (IP)(IC), AX
-    self.Emit("MOVQ"   , jit.Imm(_BM_space), _DX)       // MOVQ    _BM_space, DX
-    self.Emit("CMPQ"   , _AX, jit.Imm(' '))             // CMPQ    AX, $' '
-    self.Sjmp("JA"     , "_decode_fast")                // JA      _decode_fast
-    self.Emit("BTQ"    , _AX, _DX)                      // BTQ     _AX, _DX
-    self.Sjmp("JNC"    , "_decode_fast")                // JNC     _decode_fast
-    self.Emit("ADDQ"   , jit.Imm(1), _IC)               // ADDQ    $1, IC
-
-    /* at least 1 to 3 spaces */
-    for i := 0; i < 3; i++ {
-        self.Emit("CMPQ"   , _IC, _IL)                      // CMPQ    IC, IL
-        self.Sjmp("JAE"    , "_decode_V_EOF")               // JAE     _decode_V_EOF
-        self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX)  // MOVBQZX (IP)(IC), AX
-        self.Emit("CMPQ"   , _AX, jit.Imm(' '))             // CMPQ    AX, $' '
-        self.Sjmp("JA"     , "_decode_fast")                // JA      _decode_fast
-        self.Emit("BTQ"    , _AX, _DX)                      // BTQ     _AX, _DX
-        self.Sjmp("JNC"    , "_decode_fast")                // JNC     _decode_fast
-        self.Emit("ADDQ"   , jit.Imm(1), _IC)               // ADDQ    $1, IC
-    }
-
-    /* at least 4 spaces */
-    self.Emit("CMPQ"   , _IC, _IL)                      // CMPQ    IC, IL
-    self.Sjmp("JAE"    , "_decode_V_EOF")               // JAE     _decode_V_EOF
-    self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX)  // MOVBQZX (IP)(IC), AX
-
-    /* fast path: use lookup table to select decoder */
-    self.Link("_decode_fast")                           // _decode_fast:
-    self.Byte(0x48, 0x8d, 0x3d)                         // LEAQ    ?(PC), DI
-    self.Sref("_decode_tab", 4)                         // ....    &_decode_tab
-    self.Emit("MOVLQSX", jit.Sib(_DI, _AX, 4, 0), _AX)  // MOVLQSX (DI)(AX*4), AX
-    self.Emit("TESTQ"  , _AX, _AX)                      // TESTQ   AX, AX
-    self.Sjmp("JZ"     , "_decode_native")              // JZ      _decode_native
-    self.Emit("ADDQ"   , jit.Imm(1), _IC)               // ADDQ    $1, IC
-    self.Emit("ADDQ"   , _DI, _AX)                      // ADDQ    DI, AX
-    self.Rjmp("JMP"    , _AX)                           // JMP     AX
-
-    /* decode with native decoder */
-    self.Link("_decode_native")         // _decode_native:
-    self.Emit("MOVQ", _IP, _DI)         // MOVQ IP, DI
-    self.Emit("MOVQ", _IL, _SI)         // MOVQ IL, SI
-    self.Emit("MOVQ", _IC, _DX)         // MOVQ IC, DX
-    self.Emit("LEAQ", _VAR_ss, _CX)     // LEAQ ss, CX
-    self.Emit("MOVQ", _VAR_df, _R8)     // MOVQ $df, R8
-    self.Emit("BTSQ", jit.Imm(_F_allow_control), _R8)  // ANDQ $1<<_F_allow_control, R8
-    self.callc(_F_value)               // CALL value
-    self.Emit("MOVQ", _AX, _IC)         // MOVQ AX, IC
-
-    /* check for errors */
-    self.Emit("MOVQ" , _VAR_ss_Vt, _AX)     // MOVQ  ss.Vt, AX
-    self.Emit("TESTQ", _AX, _AX)            // TESTQ AX, AX
-    self.Sjmp("JS"   , "_parsing_error")       
-    self.Sjmp("JZ"   , "_invalid_vtype")    // JZ    _invalid_vtype
-    self.Emit("CMPQ" , _AX, _V_max)         // CMPQ  AX, _V_max
-    self.Sjmp("JA"   , "_invalid_vtype")    // JA    _invalid_vtype
-
-    /* jump table selector */
-    self.Byte(0x48, 0x8d, 0x3d)                             // LEAQ    ?(PC), DI
-    self.Sref("_switch_table", 4)                           // ....    &_switch_table
-    self.Emit("MOVLQSX", jit.Sib(_DI, _AX, 4, -4), _AX)     // MOVLQSX -4(DI)(AX*4), AX
-    self.Emit("ADDQ"   , _DI, _AX)                          // ADDQ    DI, AX
-    self.Rjmp("JMP"    , _AX)                               // JMP     AX
-
-    /** V_EOF **/
-    self.Link("_decode_V_EOF")          // _decode_V_EOF:
-    self.Emit("MOVL", _E_eof, _EP)      // MOVL _E_eof, EP
-    self.Sjmp("JMP" , "_error")         // JMP  _error
-
-    /** V_NULL **/
-    self.Link("_decode_V_NULL")                 // _decode_V_NULL:
-    self.Emit("XORL", _R8, _R8)                 // XORL R8, R8
-    self.Emit("XORL", _R9, _R9)                 // XORL R9, R9
-    self.Emit("LEAQ", jit.Ptr(_IC, -4), _DI)    // LEAQ -4(IC), DI
-    self.Sjmp("JMP" , "_set_value")             // JMP  _set_value
-
-    /** V_TRUE **/
-    self.Link("_decode_V_TRUE")                 // _decode_V_TRUE:
-    self.Emit("MOVQ", _T_bool, _R8)             // MOVQ _T_bool, R8
-    // TODO: maybe modified by users?
-    self.Emit("MOVQ", _V_true, _R9)             // MOVQ _V_true, R9 
-    self.Emit("LEAQ", jit.Ptr(_IC, -4), _DI)    // LEAQ -4(IC), DI
-    self.Sjmp("JMP" , "_set_value")             // JMP  _set_value
-
-    /** V_FALSE **/
-    self.Link("_decode_V_FALSE")                // _decode_V_FALSE:
-    self.Emit("MOVQ", _T_bool, _R8)             // MOVQ _T_bool, R8
-    self.Emit("MOVQ", _V_false, _R9)            // MOVQ _V_false, R9
-    self.Emit("LEAQ", jit.Ptr(_IC, -5), _DI)    // LEAQ -5(IC), DI
-    self.Sjmp("JMP" , "_set_value")             // JMP  _set_value
-
-    /** V_ARRAY **/
-    self.Link("_decode_V_ARRAY")                            // _decode_V_ARRAY
-    self.Emit("MOVL", jit.Imm(_S_vmask), _DX)               // MOVL _S_vmask, DX
-    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
-    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)    // MOVQ ST.Vt[CX], AX
-    self.Emit("BTQ" , _AX, _DX)                             // BTQ  AX, DX
-    self.Sjmp("JNC" , "_invalid_char")                      // JNC  _invalid_char
-
-    /* create a new array */
-    self.Emit("MOVQ", _T_eface, _AX)                            // MOVQ    _T_eface, AX
-    self.Emit("MOVQ", jit.Imm(_A_init_len), _BX)                // MOVQ    _A_init_len, BX
-    self.Emit("MOVQ", jit.Imm(_A_init_cap), _CX)                // MOVQ    _A_init_cap, CX
-    self.call_go(_F_makeslice)                                  // CALL_GO runtime.makeslice
-
-    /* pack into an interface */
-    self.Emit("MOVQ", jit.Imm(_A_init_len), _BX)                // MOVQ    _A_init_len, BX
-    self.Emit("MOVQ", jit.Imm(_A_init_cap), _CX)                // MOVQ    _A_init_cap, CX
-    self.call_go(_F_convTslice)                                 // CALL_GO runtime.convTslice
-    self.Emit("MOVQ", _AX, _R8)                                 // MOVQ    AX, R8
-
-    /* replace current state with an array */
-    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                        // MOVQ ST.Sp, CX
-    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)                // MOVQ ST.Vp[CX], SI
-    self.Emit("MOVQ", jit.Imm(_S_arr), jit.Sib(_ST, _CX, 8, _ST_Vt))    // MOVQ _S_arr, ST.Vt[CX]
-    self.Emit("MOVQ", _T_slice, _AX)                                    // MOVQ _T_slice, AX
-    self.Emit("MOVQ", _AX, jit.Ptr(_SI, 0))                             // MOVQ AX, (SI)
-    self.WriteRecNotAX(2, _R8, jit.Ptr(_SI, 8), false)                  // MOVQ R8, 8(SI)
-
-    /* add a new slot for the first element */
-    self.Emit("ADDQ", jit.Imm(1), _CX)                                  // ADDQ $1, CX
-    self.Emit("CMPQ", _CX, jit.Imm(types.MAX_RECURSE))                  // CMPQ CX, ${types.MAX_RECURSE}
-    self.Sjmp("JAE"  , "_stack_overflow")                                // JA   _stack_overflow
-    self.Emit("MOVQ", jit.Ptr(_R8, 0), _AX)                             // MOVQ (R8), AX
-    self.Emit("MOVQ", _CX, jit.Ptr(_ST, _ST_Sp))                        // MOVQ CX, ST.Sp
-    self.WritePtrAX(3, jit.Sib(_ST, _CX, 8, _ST_Vp), false)             // MOVQ AX, ST.Vp[CX]
-    self.Emit("MOVQ", jit.Imm(_S_arr_0), jit.Sib(_ST, _CX, 8, _ST_Vt))  // MOVQ _S_arr_0, ST.Vt[CX]
-    self.Sjmp("JMP" , "_next")                                          // JMP  _next
-
-    /** V_OBJECT **/
-    self.Link("_decode_V_OBJECT")                                       // _decode_V_OBJECT:
-    self.Emit("MOVL", jit.Imm(_S_vmask), _DX)                           // MOVL    _S_vmask, DX
-    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                        // MOVQ    ST.Sp, CX
-    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)                // MOVQ    ST.Vt[CX], AX
-    self.Emit("BTQ" , _AX, _DX)                                         // BTQ     AX, DX
-    self.Sjmp("JNC" , "_invalid_char")                                  // JNC     _invalid_char
-    self.call_go(_F_makemap_small)                                      // CALL_GO runtime.makemap_small
-    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                        // MOVQ    ST.Sp, CX
-    self.Emit("MOVQ", jit.Imm(_S_obj_0), jit.Sib(_ST, _CX, 8, _ST_Vt))    // MOVQ    _S_obj_0, ST.Vt[CX]
-    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)                // MOVQ    ST.Vp[CX], SI
-    self.Emit("MOVQ", _T_map, _DX)                                      // MOVQ    _T_map, DX
-    self.Emit("MOVQ", _DX, jit.Ptr(_SI, 0))                             // MOVQ    DX, (SI)
-    self.WritePtrAX(4, jit.Ptr(_SI, 8), false)                          // MOVQ    AX, 8(SI)
-    self.Sjmp("JMP" , "_next")                                          // JMP     _next
-
-    /** V_STRING **/
-    self.Link("_decode_V_STRING")       // _decode_V_STRING:
-    self.Emit("MOVQ", _VAR_ss_Iv, _CX)  // MOVQ ss.Iv, CX
-    self.Emit("MOVQ", _IC, _AX)         // MOVQ IC, AX
-    self.Emit("SUBQ", _CX, _AX)         // SUBQ CX, AX
-
-    /* check for escapes */
-    self.Emit("CMPQ", _VAR_ss_Ep, jit.Imm(-1))          // CMPQ ss.Ep, $-1
-    self.Sjmp("JNE" , "_unquote")                       // JNE  _unquote
-    self.Emit("SUBQ", jit.Imm(1), _AX)                  // SUBQ $1, AX
-    self.Emit("LEAQ", jit.Sib(_IP, _CX, 1, 0), _R8)     // LEAQ (IP)(CX), R8
-    self.Byte(0x48, 0x8d, 0x3d)                         // LEAQ (PC), DI
-    self.Sref("_copy_string_end", 4)
-    self.Emit("BTQ", jit.Imm(_F_copy_string), _VAR_df)
-    self.Sjmp("JC", "copy_string")
-    self.Link("_copy_string_end")                                 
-    self.Emit("XORL", _DX, _DX)   
-
-    /* strings with no escape sequences */
-    self.Link("_noescape")                                  // _noescape:
-    self.Emit("MOVL", jit.Imm(_S_omask_key), _DI)               // MOVL _S_omask, DI
-    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
-    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _SI)    // MOVQ ST.Vt[CX], SI
-    self.Emit("BTQ" , _SI, _DI)                             // BTQ  SI, DI
-    self.Sjmp("JC"  , "_object_key")                        // JC   _object_key
-
-    /* check for pre-packed strings, avoid 1 allocation */
-    self.Emit("TESTQ", _DX, _DX)                // TESTQ   DX, DX
-    self.Sjmp("JNZ"  , "_packed_str")           // JNZ     _packed_str
-    self.Emit("MOVQ" , _AX, _BX)                // MOVQ    AX, BX
-    self.Emit("MOVQ" , _R8, _AX)                // MOVQ    R8, AX
-    self.call_go(_F_convTstring)                // CALL_GO runtime.convTstring
-    self.Emit("MOVQ" , _AX, _R9)                // MOVQ    AX, R9
-
-    /* packed string already in R9 */
-    self.Link("_packed_str")            // _packed_str:
-    self.Emit("MOVQ", _T_string, _R8)   // MOVQ _T_string, R8
-    self.Emit("MOVQ", _VAR_ss_Iv, _DI)  // MOVQ ss.Iv, DI
-    self.Emit("SUBQ", jit.Imm(1), _DI)  // SUBQ $1, DI
-    self.Sjmp("JMP" , "_set_value")     // JMP  _set_value
-
-    /* the string is an object key, get the map */
-    self.Link("_object_key")
-    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
-    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)    // MOVQ ST.Vp[CX], SI
-    self.Emit("MOVQ", jit.Ptr(_SI, 8), _SI)                 // MOVQ 8(SI), SI
-
-    /* add a new delimiter */
-    self.Emit("ADDQ", jit.Imm(1), _CX)                                      // ADDQ $1, CX
-    self.Emit("CMPQ", _CX, jit.Imm(types.MAX_RECURSE))                      // CMPQ CX, ${types.MAX_RECURSE}
-    self.Sjmp("JAE"  , "_stack_overflow")                                    // JA   _stack_overflow
-    self.Emit("MOVQ", _CX, jit.Ptr(_ST, _ST_Sp))                            // MOVQ CX, ST.Sp
-    self.Emit("MOVQ", jit.Imm(_S_obj_delim), jit.Sib(_ST, _CX, 8, _ST_Vt))  // MOVQ _S_obj_delim, ST.Vt[CX]
-
-    /* add a new slot int the map */
-    self.Emit("MOVQ", _AX, _DI)                         // MOVQ    AX, DI
-    self.Emit("MOVQ", _T_map, _AX)                      // MOVQ    _T_map, AX
-    self.Emit("MOVQ", _SI, _BX)                         // MOVQ    SI, BX
-    self.Emit("MOVQ", _R8, _CX)                         // MOVQ    R9, CX
-    self.call_go(_F_mapassign_faststr)                  // CALL_GO runtime.mapassign_faststr
-
-    /* add to the pointer stack */
-    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                 // MOVQ ST.Sp, CX
-    self.WritePtrAX(6, jit.Sib(_ST, _CX, 8, _ST_Vp), false)    // MOVQ AX, ST.Vp[CX]
-    self.Sjmp("JMP" , "_next")                                   // JMP  _next
-
-    /* allocate memory to store the string header and unquoted result */
-    self.Link("_unquote")                               // _unquote:
-    self.Emit("ADDQ", jit.Imm(15), _AX)                 // ADDQ    $15, AX
-    self.Emit("MOVQ", _T_byte, _BX)                     // MOVQ    _T_byte, BX
-    self.Emit("MOVB", jit.Imm(0), _CX)                  // MOVB    $0, CX
-    self.call_go(_F_mallocgc)                           // CALL_GO runtime.mallocgc
-    self.Emit("MOVQ", _AX, _R9)                         // MOVQ    AX, R9
-
-    /* prepare the unquoting parameters */
-    self.Emit("MOVQ" , _VAR_ss_Iv, _CX)                         // MOVQ  ss.Iv, CX
-    self.Emit("LEAQ" , jit.Sib(_IP, _CX, 1, 0), _DI)            // LEAQ  (IP)(CX), DI
-    self.Emit("NEGQ" , _CX)                                     // NEGQ  CX
-    self.Emit("LEAQ" , jit.Sib(_IC, _CX, 1, -1), _SI)           // LEAQ  -1(IC)(CX), SI
-    self.Emit("LEAQ" , jit.Ptr(_R9, 16), _DX)                   // LEAQ  16(R8), DX
-    self.Emit("LEAQ" , _VAR_ss_Ep, _CX)                         // LEAQ  ss.Ep, CX
-    self.Emit("XORL" , _R8, _R8)                                // XORL  R8, R8
-    self.Emit("BTQ"  , jit.Imm(_F_disable_urc), _VAR_df)        // BTQ   ${_F_disable_urc}, fv
-    self.Emit("SETCC", _R8)                                     // SETCC R8
-    self.Emit("SHLQ" , jit.Imm(types.B_UNICODE_REPLACE), _R8)   // SHLQ  ${types.B_UNICODE_REPLACE}, R8
-
-    /* unquote the string, with R9 been preserved */
-    self.Emit("MOVQ", _R9, _VAR_R9)             // SAVE R9
-    self.call_c(_F_unquote)                     // CALL unquote
-    self.Emit("MOVQ", _VAR_R9, _R9)             // LOAD R9
-
-    /* check for errors */
-    self.Emit("TESTQ", _AX, _AX)                // TESTQ AX, AX
-    self.Sjmp("JS"   , "_unquote_error")        // JS    _unquote_error
-    self.Emit("MOVL" , jit.Imm(1), _DX)         // MOVL  $1, DX
-    self.Emit("LEAQ" , jit.Ptr(_R9, 16), _R8)   // ADDQ  $16, R8
-    self.Emit("MOVQ" , _R8, jit.Ptr(_R9, 0))    // MOVQ  R8, (R9)
-    self.Emit("MOVQ" , _AX, jit.Ptr(_R9, 8))    // MOVQ  AX, 8(R9)
-    self.Sjmp("JMP"  , "_noescape")             // JMP   _noescape
-
-    /** V_DOUBLE **/
-    self.Link("_decode_V_DOUBLE")                           // _decode_V_DOUBLE:
-    self.Emit("BTQ"  , jit.Imm(_F_use_number), _VAR_df)     // BTQ     _F_use_number, df
-    self.Sjmp("JC"   , "_use_number")                       // JC      _use_number
-    self.Emit("MOVSD", _VAR_ss_Dv, _X0)                     // MOVSD   ss.Dv, X0
-    self.Sjmp("JMP"  , "_use_float64")                      // JMP     _use_float64
-
-    /** V_INTEGER **/
-    self.Link("_decode_V_INTEGER")                          // _decode_V_INTEGER:
-    self.Emit("BTQ"     , jit.Imm(_F_use_number), _VAR_df)  // BTQ      _F_use_number, df
-    self.Sjmp("JC"      , "_use_number")                    // JC       _use_number
-    self.Emit("BTQ"     , jit.Imm(_F_use_int64), _VAR_df)   // BTQ      _F_use_int64, df
-    self.Sjmp("JC"      , "_use_int64")                     // JC       _use_int64
-    //TODO: use ss.Dv directly
-    self.Emit("MOVSD", _VAR_ss_Dv, _X0)                  // MOVSD   ss.Dv, X0
-
-    /* represent numbers as `float64` */
-    self.Link("_use_float64")                   // _use_float64:
-    self.Emit("MOVQ" , _X0, _AX)                // MOVQ   X0, AX
-    self.call_go(_F_convT64)                    // CALL_GO runtime.convT64
-    self.Emit("MOVQ" , _T_float64, _R8)         // MOVQ    _T_float64, R8
-    self.Emit("MOVQ" , _AX, _R9)                // MOVQ    AX, R9
-    self.Emit("MOVQ" , _VAR_ss_Ep, _DI)         // MOVQ    ss.Ep, DI
-    self.Sjmp("JMP"  , "_set_value")            // JMP     _set_value
-
-    /* represent numbers as `json.Number` */
-    self.Link("_use_number")                            // _use_number
-    self.Emit("MOVQ", _VAR_ss_Ep, _AX)                  // MOVQ    ss.Ep, AX
-    self.Emit("LEAQ", jit.Sib(_IP, _AX, 1, 0), _SI)     // LEAQ    (IP)(AX), SI
-    self.Emit("MOVQ", _IC, _CX)                         // MOVQ    IC, CX
-    self.Emit("SUBQ", _AX, _CX)                         // SUBQ    AX, CX
-    self.Emit("MOVQ", _SI, _AX)                         // MOVQ    SI, AX
-    self.Emit("MOVQ", _CX, _BX)                         // MOVQ    CX, BX
-    self.call_go(_F_convTstring)                        // CALL_GO runtime.convTstring
-    self.Emit("MOVQ", _T_number, _R8)                   // MOVQ    _T_number, R8
-    self.Emit("MOVQ", _AX, _R9)                         // MOVQ    AX, R9
-    self.Emit("MOVQ", _VAR_ss_Ep, _DI)                  // MOVQ    ss.Ep, DI
-    self.Sjmp("JMP" , "_set_value")                     // JMP     _set_value
-
-    /* represent numbers as `int64` */
-    self.Link("_use_int64")                     // _use_int64:
-    self.Emit("MOVQ", _VAR_ss_Iv, _AX)          // MOVQ    ss.Iv, AX
-    self.call_go(_F_convT64)                    // CALL_GO runtime.convT64
-    self.Emit("MOVQ", _T_int64, _R8)            // MOVQ    _T_int64, R8
-    self.Emit("MOVQ", _AX, _R9)                 // MOVQ    AX, R9
-    self.Emit("MOVQ", _VAR_ss_Ep, _DI)          // MOVQ    ss.Ep, DI
-    self.Sjmp("JMP" , "_set_value")             // JMP     _set_value
-
-    /** V_KEY_SEP **/
-    self.Link("_decode_V_KEY_SEP")                                          // _decode_V_KEY_SEP:
-    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                            // MOVQ ST.Sp, CX
-    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)                    // MOVQ ST.Vt[CX], AX
-    self.Emit("CMPQ", _AX, jit.Imm(_S_obj_delim))                           // CMPQ AX, _S_obj_delim
-    self.Sjmp("JNE" , "_invalid_char")                                      // JNE  _invalid_char
-    self.Emit("MOVQ", jit.Imm(_S_val), jit.Sib(_ST, _CX, 8, _ST_Vt))        // MOVQ _S_val, ST.Vt[CX]
-    self.Emit("MOVQ", jit.Imm(_S_obj), jit.Sib(_ST, _CX, 8, _ST_Vt - 8))    // MOVQ _S_obj, ST.Vt[CX - 1]
-    self.Sjmp("JMP" , "_next")                                              // JMP  _next
-
-    /** V_ELEM_SEP **/
-    self.Link("_decode_V_ELEM_SEP")                          // _decode_V_ELEM_SEP:
-    self.Emit("MOVQ" , jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ     ST.Sp, CX
-    self.Emit("MOVQ" , jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)    // MOVQ     ST.Vt[CX], AX
-    self.Emit("CMPQ" , _AX, jit.Imm(_S_arr))      
-    self.Sjmp("JE"   , "_array_sep")                         // JZ       _next
-    self.Emit("CMPQ" , _AX, jit.Imm(_S_obj))                 // CMPQ     _AX, _S_arr
-    self.Sjmp("JNE"  , "_invalid_char")                      // JNE      _invalid_char
-    self.Emit("MOVQ" , jit.Imm(_S_obj_sep), jit.Sib(_ST, _CX, 8, _ST_Vt))
-    self.Sjmp("JMP"  , "_next")                              // JMP      _next
-
-    /* arrays */
-    self.Link("_array_sep")
-    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)    // MOVQ ST.Vp[CX], SI
-    self.Emit("MOVQ", jit.Ptr(_SI, 8), _SI)                 // MOVQ 8(SI), SI
-    self.Emit("MOVQ", jit.Ptr(_SI, 8), _DX)                 // MOVQ 8(SI), DX
-    self.Emit("CMPQ", _DX, jit.Ptr(_SI, 16))                // CMPQ DX, 16(SI)
-    self.Sjmp("JAE" , "_array_more")                        // JAE  _array_more
-
-    /* add a slot for the new element */
-    self.Link("_array_append")                                          // _array_append:
-    self.Emit("ADDQ", jit.Imm(1), jit.Ptr(_SI, 8))                      // ADDQ $1, 8(SI)
-    self.Emit("MOVQ", jit.Ptr(_SI, 0), _SI)                             // MOVQ (SI), SI
-    self.Emit("ADDQ", jit.Imm(1), _CX)                                  // ADDQ $1, CX
-    self.Emit("CMPQ", _CX, jit.Imm(types.MAX_RECURSE))                  // CMPQ CX, ${types.MAX_RECURSE}
-    self.Sjmp("JAE"  , "_stack_overflow")                                // JA   _stack_overflow
-    self.Emit("SHLQ", jit.Imm(1), _DX)                                  // SHLQ $1, DX
-    self.Emit("LEAQ", jit.Sib(_SI, _DX, 8, 0), _SI)                     // LEAQ (SI)(DX*8), SI
-    self.Emit("MOVQ", _CX, jit.Ptr(_ST, _ST_Sp))                        // MOVQ CX, ST.Sp
-    self.WriteRecNotAX(7 , _SI, jit.Sib(_ST, _CX, 8, _ST_Vp), false)           // MOVQ SI, ST.Vp[CX]
-    self.Emit("MOVQ", jit.Imm(_S_val), jit.Sib(_ST, _CX, 8, _ST_Vt))    // MOVQ _S_val, ST.Vt[CX}
-    self.Sjmp("JMP" , "_next")                                          // JMP  _next
-
-    /** V_ARRAY_END **/
-    self.Link("_decode_V_ARRAY_END")                        // _decode_V_ARRAY_END:
-    self.Emit("XORL", _DX, _DX)                             // XORL DX, DX
-    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
-    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)    // MOVQ ST.Vt[CX], AX
-    self.Emit("CMPQ", _AX, jit.Imm(_S_arr_0))               // CMPQ AX, _S_arr_0
-    self.Sjmp("JE"  , "_first_item")                        // JE   _first_item
-    self.Emit("CMPQ", _AX, jit.Imm(_S_arr))                 // CMPQ AX, _S_arr
-    self.Sjmp("JNE" , "_invalid_char")                      // JNE  _invalid_char
-    self.Emit("SUBQ", jit.Imm(1), jit.Ptr(_ST, _ST_Sp))     // SUBQ $1, ST.Sp
-    self.Emit("MOVQ", _DX, jit.Sib(_ST, _CX, 8, _ST_Vp))    // MOVQ DX, ST.Vp[CX]
-    self.Sjmp("JMP" , "_next")                              // JMP  _next
-
-    /* first element of an array */
-    self.Link("_first_item")                                    // _first_item:
-    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                // MOVQ ST.Sp, CX
-    self.Emit("SUBQ", jit.Imm(2), jit.Ptr(_ST, _ST_Sp))         // SUBQ $2, ST.Sp
-    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp - 8), _SI)    // MOVQ ST.Vp[CX - 1], SI
-    self.Emit("MOVQ", jit.Ptr(_SI, 8), _SI)                     // MOVQ 8(SI), SI
-    self.Emit("MOVQ", _DX, jit.Sib(_ST, _CX, 8, _ST_Vp - 8))    // MOVQ DX, ST.Vp[CX - 1]
-    self.Emit("MOVQ", _DX, jit.Sib(_ST, _CX, 8, _ST_Vp))        // MOVQ DX, ST.Vp[CX]
-    self.Emit("MOVQ", _DX, jit.Ptr(_SI, 8))                     // MOVQ DX, 8(SI)
-    self.Sjmp("JMP" , "_next")                                  // JMP  _next
-
-    /** V_OBJECT_END **/
-    self.Link("_decode_V_OBJECT_END")                       // _decode_V_OBJECT_END:
-    self.Emit("MOVL", jit.Imm(_S_omask_end), _DI)           // MOVL _S_omask, DI
-    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
-    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)    // MOVQ ST.Vt[CX], AX
-    self.Emit("BTQ" , _AX, _DI)                    
-    self.Sjmp("JNC" , "_invalid_char")                      // JNE  _invalid_char
-    self.Emit("XORL", _AX, _AX)                             // XORL AX, AX
-    self.Emit("SUBQ", jit.Imm(1), jit.Ptr(_ST, _ST_Sp))     // SUBQ $1, ST.Sp
-    self.Emit("MOVQ", _AX, jit.Sib(_ST, _CX, 8, _ST_Vp))    // MOVQ AX, ST.Vp[CX]
-    self.Sjmp("JMP" , "_next")                              // JMP  _next
-
-    /* return from decoder */
-    self.Link("_return")                            // _return:
-    self.Emit("XORL", _EP, _EP)                     // XORL EP, EP
-    self.Emit("MOVQ", _EP, jit.Ptr(_ST, _ST_Vp))    // MOVQ EP, ST.Vp[0]
-    self.Link("_epilogue")                          // _epilogue:
-    self.Emit("SUBQ", jit.Imm(_FsmOffset), _ST)     // SUBQ _FsmOffset, _ST
-    self.Emit("MOVQ", jit.Ptr(_SP, _VD_offs), _BP)  // MOVQ _VD_offs(SP), BP
-    self.Emit("ADDQ", jit.Imm(_VD_size), _SP)       // ADDQ $_VD_size, SP
-    self.Emit("RET")                                // RET
-
-    /* array expand */
-    self.Link("_array_more")                    // _array_more:
-    self.Emit("MOVQ" , _T_eface, _AX)           // MOVQ    _T_eface, AX
-    self.Emit("MOVQ" , jit.Ptr(_SI, 0), _BX)    // MOVQ   (SI), BX
-    self.Emit("MOVQ" , jit.Ptr(_SI, 8), _CX)    // MOVQ   8(SI), CX
-    self.Emit("MOVQ" , jit.Ptr(_SI, 16), _DI)   // MOVQ    16(SI), DI
-    self.Emit("MOVQ" , _DI, _SI)                // MOVQ    DI, 24(SP)
-    self.Emit("SHLQ" , jit.Imm(1), _SI)         // SHLQ    $1, SI
-    self.call_go(_F_growslice)                  // CALL_GO runtime.growslice
-    self.Emit("MOVQ" , _AX, _DI)                // MOVQ   AX, DI
-    self.Emit("MOVQ" , _BX, _DX)                // MOVQ   BX, DX
-    self.Emit("MOVQ" , _CX, _AX)                // MOVQ   CX, AX
-             
-    /* update the slice */
-    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
-    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)    // MOVQ ST.Vp[CX], SI
-    self.Emit("MOVQ", jit.Ptr(_SI, 8), _SI)                 // MOVQ 8(SI), SI
-    self.Emit("MOVQ", _DX, jit.Ptr(_SI, 8))                 // MOVQ DX, 8(SI)
-    self.Emit("MOVQ", _AX, jit.Ptr(_SI, 16))                // MOVQ AX, 16(AX)
-    self.WriteRecNotAX(8 , _DI, jit.Ptr(_SI, 0), false)                 // MOVQ R10, (SI)
-    self.Sjmp("JMP" , "_array_append")                      // JMP  _array_append
-
-    /* copy string */
-    self.Link("copy_string")  // pointer: R8, length: AX, return addr: DI
-    self.Emit("MOVQ", _R8, _VAR_cs_p)
-    self.Emit("MOVQ", _AX, _VAR_cs_n)
-    self.Emit("MOVQ", _DI, _VAR_cs_LR)
-    self.Emit("MOVQ", _AX, _BX)
-    self.Emit("MOVQ", _AX, _CX)
-    self.Emit("MOVQ", _T_byte, _AX)
-    self.call_go(_F_makeslice)                              
-    self.Emit("MOVQ", _AX, _VAR_cs_d)                    
-    self.Emit("MOVQ", _VAR_cs_p, _BX)
-    self.Emit("MOVQ", _VAR_cs_n, _CX)
-    self.call_go(_F_memmove)
-    self.Emit("MOVQ", _VAR_cs_d, _R8)
-    self.Emit("MOVQ", _VAR_cs_n, _AX)
-    self.Emit("MOVQ", _VAR_cs_LR, _DI)
-    self.Rjmp("JMP", _DI)
-
-    /* error handlers */
-    self.Link("_stack_overflow")
-    self.Emit("MOVL" , _E_recurse, _EP)         // MOVQ  _E_recurse, EP
-    self.Sjmp("JMP"  , "_error")                // JMP   _error
-    self.Link("_vtype_error")                   // _vtype_error:
-    self.Emit("MOVQ" , _DI, _IC)                // MOVQ  DI, IC
-    self.Emit("MOVL" , _E_invalid, _EP)         // MOVL  _E_invalid, EP
-    self.Sjmp("JMP"  , "_error")                // JMP   _error
-    self.Link("_invalid_char")                  // _invalid_char:
-    self.Emit("SUBQ" , jit.Imm(1), _IC)         // SUBQ  $1, IC
-    self.Emit("MOVL" , _E_invalid, _EP)         // MOVL  _E_invalid, EP
-    self.Sjmp("JMP"  , "_error")                // JMP   _error
-    self.Link("_unquote_error")                 // _unquote_error:
-    self.Emit("MOVQ" , _VAR_ss_Iv, _IC)         // MOVQ  ss.Iv, IC
-    self.Emit("SUBQ" , jit.Imm(1), _IC)         // SUBQ  $1, IC
-    self.Link("_parsing_error")                 // _parsing_error:
-    self.Emit("NEGQ" , _AX)                     // NEGQ  AX
-    self.Emit("MOVQ" , _AX, _EP)                // MOVQ  AX, EP
-    self.Link("_error")                         // _error:
-    self.Emit("PXOR" , _X0, _X0)                // PXOR  X0, X0
-    self.Emit("MOVOU", _X0, jit.Ptr(_VP, 0))    // MOVOU X0, (VP)
-    self.Sjmp("JMP"  , "_epilogue")             // JMP   _epilogue
-
-    /* invalid value type, never returns */
-    self.Link("_invalid_vtype")
-    self.call_go(_F_invalid_vtype)                 // CALL invalid_type
-    self.Emit("UD2")                            // UD2
-
-    /* switch jump table */
-    self.Link("_switch_table")              // _switch_table:
-    self.Sref("_decode_V_EOF", 0)           // SREF &_decode_V_EOF, $0
-    self.Sref("_decode_V_NULL", -4)         // SREF &_decode_V_NULL, $-4
-    self.Sref("_decode_V_TRUE", -8)         // SREF &_decode_V_TRUE, $-8
-    self.Sref("_decode_V_FALSE", -12)       // SREF &_decode_V_FALSE, $-12
-    self.Sref("_decode_V_ARRAY", -16)       // SREF &_decode_V_ARRAY, $-16
-    self.Sref("_decode_V_OBJECT", -20)      // SREF &_decode_V_OBJECT, $-20
-    self.Sref("_decode_V_STRING", -24)      // SREF &_decode_V_STRING, $-24
-    self.Sref("_decode_V_DOUBLE", -28)      // SREF &_decode_V_DOUBLE, $-28
-    self.Sref("_decode_V_INTEGER", -32)     // SREF &_decode_V_INTEGER, $-32
-    self.Sref("_decode_V_KEY_SEP", -36)     // SREF &_decode_V_KEY_SEP, $-36
-    self.Sref("_decode_V_ELEM_SEP", -40)    // SREF &_decode_V_ELEM_SEP, $-40
-    self.Sref("_decode_V_ARRAY_END", -44)   // SREF &_decode_V_ARRAY_END, $-44
-    self.Sref("_decode_V_OBJECT_END", -48)  // SREF &_decode_V_OBJECT_END, $-48
-
-    /* fast character lookup table */
-    self.Link("_decode_tab")        // _decode_tab:
-    self.Sref("_decode_V_EOF", 0)   // SREF &_decode_V_EOF, $0
-
-    /* generate rest of the tabs */
-    for i := 1; i < 256; i++ {
-        if to, ok := _R_tab[i]; ok {
-            self.Sref(to, -int64(i) * 4)
-        } else {
-            self.Byte(0x00, 0x00, 0x00, 0x00)
-        }
-    }
-}
-
-func (self *_ValueDecoder) WritePtrAX(i int, rec obj.Addr, saveDI bool) {
-    self.Emit("MOVQ", _V_writeBarrier, _R9)
-    self.Emit("CMPL", jit.Ptr(_R9, 0), jit.Imm(0))
-    self.Sjmp("JE", "_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
-    if saveDI {
-        self.save(_DI)
-    }
-    self.Emit("LEAQ", rec, _DI)
-    self.call(_F_gcWriteBarrierAX)
-    if saveDI {
-        self.load(_DI)
-    }    
-    self.Sjmp("JMP", "_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
-    self.Link("_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
-    self.Emit("MOVQ", _AX, rec)
-    self.Link("_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
-}
-
-func (self *_ValueDecoder) WriteRecNotAX(i int, ptr obj.Addr, rec obj.Addr, saveDI bool) {
-    if rec.Reg == x86.REG_AX || rec.Index == x86.REG_AX {
-        panic("rec contains AX!")
-    }
-    self.Emit("MOVQ", _V_writeBarrier, _AX)
-    self.Emit("CMPL", jit.Ptr(_AX, 0), jit.Imm(0))
-    self.Sjmp("JE", "_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
-    self.Emit("MOVQ", ptr, _AX)
-    if saveDI {
-        self.save(_DI)
-    }
-    self.Emit("LEAQ", rec, _DI)
-    self.call(_F_gcWriteBarrierAX)
-    if saveDI {
-        self.load(_DI)
-    }    
-    self.Sjmp("JMP", "_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
-    self.Link("_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
-    self.Emit("MOVQ", ptr, rec)
-    self.Link("_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
-}
-
-/** Generic Decoder **/
-
-var (
-    _subr_decode_value = new(_ValueDecoder).build()
-)
-
-//go:nosplit
-func invalid_vtype(vt types.ValueType) {
-    throw(fmt.Sprintf("invalid value type: %d", vt))
-}

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

@@ -1,37 +0,0 @@
-// +build go1.17,!go1.21
-
-//
-// Copyright 2021 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.
-//
-
-#include "go_asm.h"
-#include "funcdata.h"
-#include "textflag.h"
-
-TEXT ·decodeValueStub(SB), NOSPLIT, $0 - 72
-    NO_LOCAL_POINTERS
-    PXOR  X0, X0
-    MOVOU X0, rv+48(FP)
-    MOVQ  st+0(FP) , R13
-    MOVQ  sp+8(FP) , R10
-    MOVQ  sn+16(FP), R12
-    MOVQ  ic+24(FP), R11
-    MOVQ  vp+32(FP), R15
-    MOVQ  df+40(FP), AX
-    MOVQ  ·_subr_decode_value(SB), BX
-    CALL  BX
-    MOVQ  R11, rp+48(FP)
-    MOVQ  BX, ex+56(FP)
-    RET

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

@@ -1,37 +0,0 @@
-// +build go1.15,!go1.17
-
-//
-// Copyright 2021 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.
-//
-
-#include "go_asm.h"
-#include "funcdata.h"
-#include "textflag.h"
-
-TEXT ·decodeValueStub(SB), NOSPLIT, $0 - 72
-    NO_LOCAL_POINTERS
-    PXOR  X0, X0
-    MOVOU X0, rv+48(FP)
-    MOVQ  st+0(FP), BX
-    MOVQ  sp+8(FP), R12
-    MOVQ  sn+16(FP), R13
-    MOVQ  ic+24(FP), R14
-    MOVQ  vp+32(FP), R15
-    MOVQ  df+40(FP), R10
-    MOVQ  ·_subr_decode_value(SB), AX
-    CALL  AX
-    MOVQ  R14, rp+48(FP)
-    MOVQ  R11, ex+56(FP)
-    RET

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

@@ -29,7 +29,7 @@ const (
     _MinSlice = 2
     _MaxStack = 4096 // 4k slots
     _MaxStackBytes = _MaxStack * _PtrBytes
-    _MaxDigitNums = 800  // used in atof fallback algorithm
+    _MaxDigitNums = types.MaxDigitNums  // used in atof fallback algorithm
 )
 
 const (

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

@@ -21,8 +21,9 @@ import (
     `io`
     `sync`
 
-    `github.com/bytedance/sonic/option`
+    `github.com/bytedance/sonic/internal/native`
     `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/option`
 )
 
 var (
@@ -71,6 +72,7 @@ func (self *StreamDecoder) Decode(val interface{}) (err error) {
     
     var first = true
     var repeat = true
+
 read_more:
     for {
         l := len(buf)
@@ -97,11 +99,20 @@ read_more:
     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
+            } else {
+                err = SyntaxError{x, self.s, types.ParsingError(-ret), ""}
+                self.err = err
+                return
+            }
+        }
+
         err = self.Decoder.Decode(val)
         if err != nil {
-            if repeat && self.repeatable(err) {
-                goto read_more
-            }
             self.err = err
         }
 

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

@@ -1,111 +0,0 @@
-// +build go1.15,!go1.20
-
-/*
- * Copyright 2021 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 decoder
-
-import (
-    `unsafe`
-    `reflect`
-
-    _ `github.com/chenzhuoyu/base64x`
-
-    `github.com/bytedance/sonic/internal/rt`
-)
-
-//go:linkname _subr__b64decode github.com/chenzhuoyu/base64x._subr__b64decode
-var _subr__b64decode uintptr
-
-// runtime.maxElementSize
-const _max_map_element_size uintptr = 128
-
-func mapfast(vt reflect.Type) bool {
-    return vt.Elem().Size() <= _max_map_element_size
-}
-
-//go:nosplit
-//go:linkname throw runtime.throw
-//goland:noinspection GoUnusedParameter
-func throw(s string)
-
-//go:linkname convT64 runtime.convT64
-//goland:noinspection GoUnusedParameter
-func convT64(v uint64) unsafe.Pointer
-
-//go:linkname convTslice runtime.convTslice
-//goland:noinspection GoUnusedParameter
-func convTslice(v []byte) unsafe.Pointer
-
-//go:linkname convTstring runtime.convTstring
-//goland:noinspection GoUnusedParameter
-func convTstring(v string) unsafe.Pointer
-
-//go:noescape
-//go:linkname memequal runtime.memequal
-//goland:noinspection GoUnusedParameter
-func memequal(a unsafe.Pointer, b unsafe.Pointer, size uintptr) bool
-
-//go:noescape
-//go:linkname memmove runtime.memmove
-//goland:noinspection GoUnusedParameter
-func memmove(to unsafe.Pointer, from unsafe.Pointer, n uintptr)
-
-//go:linkname mallocgc runtime.mallocgc
-//goland:noinspection GoUnusedParameter
-func mallocgc(size uintptr, typ *rt.GoType, needzero bool) unsafe.Pointer
-
-//go:linkname makeslice runtime.makeslice
-//goland:noinspection GoUnusedParameter
-func makeslice(et *rt.GoType, len int, cap int) unsafe.Pointer
-
-//go:noescape
-//go:linkname growslice runtime.growslice
-//goland:noinspection GoUnusedParameter
-func growslice(et *rt.GoType, old rt.GoSlice, cap int) rt.GoSlice
-
-//go:linkname makemap_small runtime.makemap_small
-func makemap_small() unsafe.Pointer
-
-//go:linkname mapassign runtime.mapassign
-//goland:noinspection GoUnusedParameter
-func mapassign(t *rt.GoType, h unsafe.Pointer, k unsafe.Pointer) unsafe.Pointer
-
-//go:linkname mapassign_fast32 runtime.mapassign_fast32
-//goland:noinspection GoUnusedParameter
-func mapassign_fast32(t *rt.GoType, h unsafe.Pointer, k uint32) unsafe.Pointer
-
-//go:linkname mapassign_fast64 runtime.mapassign_fast64
-//goland:noinspection GoUnusedParameter
-func mapassign_fast64(t *rt.GoType, h unsafe.Pointer, k uint64) unsafe.Pointer
-
-//go:linkname mapassign_fast64ptr runtime.mapassign_fast64ptr
-//goland:noinspection GoUnusedParameter
-func mapassign_fast64ptr(t *rt.GoType, h unsafe.Pointer, k unsafe.Pointer) unsafe.Pointer
-
-//go:linkname mapassign_faststr runtime.mapassign_faststr
-//goland:noinspection GoUnusedParameter
-func mapassign_faststr(t *rt.GoType, h unsafe.Pointer, s string) unsafe.Pointer
-
-//go:nosplit
-//go:linkname memclrHasPointers runtime.memclrHasPointers
-//goland:noinspection GoUnusedParameter
-func memclrHasPointers(ptr unsafe.Pointer, n uintptr)
-
-//go:noescape
-//go:linkname memclrNoHeapPointers runtime.memclrNoHeapPointers
-//goland:noinspection GoUnusedParameter
-func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)

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

@@ -82,23 +82,23 @@ func makemap_small() unsafe.Pointer
 
 //go:linkname mapassign runtime.mapassign
 //goland:noinspection GoUnusedParameter
-func mapassign(t *rt.GoType, h unsafe.Pointer, k unsafe.Pointer) unsafe.Pointer
+func mapassign(t *rt.GoMapType, h unsafe.Pointer, k unsafe.Pointer) unsafe.Pointer
 
 //go:linkname mapassign_fast32 runtime.mapassign_fast32
 //goland:noinspection GoUnusedParameter
-func mapassign_fast32(t *rt.GoType, h unsafe.Pointer, k uint32) unsafe.Pointer
+func mapassign_fast32(t *rt.GoMapType, h unsafe.Pointer, k uint32) unsafe.Pointer
 
 //go:linkname mapassign_fast64 runtime.mapassign_fast64
 //goland:noinspection GoUnusedParameter
-func mapassign_fast64(t *rt.GoType, h unsafe.Pointer, k uint64) unsafe.Pointer
+func mapassign_fast64(t *rt.GoMapType, h unsafe.Pointer, k uint64) unsafe.Pointer
 
 //go:linkname mapassign_fast64ptr runtime.mapassign_fast64ptr
 //goland:noinspection GoUnusedParameter
-func mapassign_fast64ptr(t *rt.GoType, h unsafe.Pointer, k unsafe.Pointer) unsafe.Pointer
+func mapassign_fast64ptr(t *rt.GoMapType, h unsafe.Pointer, k unsafe.Pointer) unsafe.Pointer
 
 //go:linkname mapassign_faststr runtime.mapassign_faststr
 //goland:noinspection GoUnusedParameter
-func mapassign_faststr(t *rt.GoType, h unsafe.Pointer, s string) unsafe.Pointer
+func mapassign_faststr(t *rt.GoMapType, h unsafe.Pointer, s string) unsafe.Pointer
 
 //go:nosplit
 //go:linkname memclrHasPointers runtime.memclrHasPointers

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

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

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

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

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

@@ -292,7 +292,6 @@ 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)
 }

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

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

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

@@ -1,4 +1,4 @@
-// +build go1.20
+// +build go1.20,!go1.21
 
 /*
  * Copyright 2021 ByteDance Inc.

vendor/github.com/bytedance/sonic/internal/loader/funcdata.go

@@ -1,124 +0,0 @@
-/*
- * Copyright 2021 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`
-    `sync`
-    `unsafe`
-
-    `github.com/bytedance/sonic/internal/rt`
-)
-
-//go:linkname lastmoduledatap runtime.lastmoduledatap
-//goland:noinspection GoUnusedGlobalVariable
-var lastmoduledatap *_ModuleData
-
-//go:linkname moduledataverify1 runtime.moduledataverify1
-func moduledataverify1(_ *_ModuleData)
-
-// PCDATA and FUNCDATA table indexes.
-//
-// See funcdata.h and $GROOT/src/cmd/internal/objabi/funcdata.go.
-const (
-    _FUNCDATA_ArgsPointerMaps = 0
-    _FUNCDATA_LocalsPointerMaps = 1
-)
-
-type funcInfo struct {
-    *_Func
-    datap *_ModuleData
-}
-
-//go:linkname findfunc runtime.findfunc
-func findfunc(pc uintptr) funcInfo
-
-//go:linkname funcdata runtime.funcdata
-func funcdata(f funcInfo, i uint8) unsafe.Pointer
-
-var (
-    modLock sync.Mutex
-    modList []*_ModuleData
-)
-
-var emptyByte byte
-
-func encodeVariant(v int) []byte {
-    var u int
-    var r []byte
-
-    /* split every 7 bits */
-    for v > 127 {
-        u = v & 0x7f
-        v = v >> 7
-        r = append(r, byte(u) | 0x80)
-    }
-
-    /* check for last one */
-    if v == 0 {
-        return r
-    }
-
-    /* add the last one */
-    r = append(r, byte(v))
-    return r
-}
-
-func registerModule(mod *_ModuleData) {
-    modLock.Lock()
-    modList = append(modList, mod)
-    lastmoduledatap.next = mod
-    lastmoduledatap = mod
-    modLock.Unlock()
-}
-
-func stackMap(f interface{}) (args uintptr, locals uintptr) {
-    fv := reflect.ValueOf(f)
-    if fv.Kind() != reflect.Func {
-        panic("f must be reflect.Func kind!")
-    }
-    fi := findfunc(fv.Pointer())
-    return uintptr(funcdata(fi, uint8(_FUNCDATA_ArgsPointerMaps))), uintptr(funcdata(fi, uint8(_FUNCDATA_LocalsPointerMaps)))
-}
-
-var moduleCache = struct{
-    m map[*_ModuleData][]byte
-    l sync.Mutex
-}{
-    m : make(map[*_ModuleData][]byte),
-}
-
-func cacheStackmap(argPtrs []bool, localPtrs []bool, mod *_ModuleData) (argptrs uintptr, localptrs uintptr) {
-    as := rt.StackMapBuilder{}
-    for _, b := range argPtrs {
-        as.AddField(b)
-    }
-    ab, _ := as.Build().MarshalBinary()
-    ls := rt.StackMapBuilder{}
-    for _, b := range localPtrs {
-        ls.AddField(b)
-    }
-    lb, _ := ls.Build().MarshalBinary()
-    cache := make([]byte, len(ab) + len(lb))
-    copy(cache, ab)
-    copy(cache[len(ab):], lb)
-    moduleCache.l.Lock()
-    moduleCache.m[mod] = cache
-    moduleCache.l.Unlock()
-    return uintptr(rt.IndexByte(cache, 0)), uintptr(rt.IndexByte(cache, len(ab)))
-
-}

vendor/github.com/bytedance/sonic/internal/loader/funcdata_go115.go

@@ -1,169 +0,0 @@
-// +build go1.15,!go1.16
-
-/*
- * Copyright 2021 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 (
-    `unsafe`
-
-    `github.com/bytedance/sonic/internal/rt`
-)
-
-type _Func struct {
-    entry       uintptr // start pc
-    nameoff     int32   // function name
-    args        int32   // in/out args size
-    deferreturn uint32  // offset of start of a deferreturn call instruction from entry, if any.
-    pcsp        int32
-    pcfile      int32
-    pcln        int32
-    npcdata     int32
-    funcID      uint8   // set for certain special runtime functions
-    _           [2]int8 // unused
-    nfuncdata   uint8   // must be last
-    argptrs     uintptr
-    localptrs   uintptr
-}
-
-type _FuncTab struct {
-    entry   uintptr
-    funcoff uintptr
-}
-
-type _BitVector struct {
-    n        int32 // # of bits
-    bytedata *uint8
-}
-
-type _PtabEntry struct {
-    name int32
-    typ  int32
-}
-
-type _TextSection struct {
-    vaddr    uintptr // prelinked section vaddr
-    length   uintptr // section length
-    baseaddr uintptr // relocated section address
-}
-
-type _ModuleData struct {
-    pclntable             []byte
-    ftab                  []_FuncTab
-    filetab               []uint32
-    findfunctab           *_FindFuncBucket
-    minpc, maxpc          uintptr
-    text, etext           uintptr
-    noptrdata, enoptrdata uintptr
-    data, edata           uintptr
-    bss, ebss             uintptr
-    noptrbss, enoptrbss   uintptr
-    end, gcdata, gcbss    uintptr
-    types, etypes         uintptr
-    textsectmap           []_TextSection
-    typelinks             []int32 // offsets from types
-    itablinks             []*rt.GoItab
-    ptab                  []_PtabEntry
-    pluginpath            string
-    pkghashes             []byte
-    modulename            string
-    modulehashes          []byte
-    hasmain               uint8 // 1 if module contains the main function, 0 otherwise
-    gcdatamask, gcbssmask _BitVector
-    typemap               map[int32]*rt.GoType // offset to *_rtype in previous module
-    bad                   bool                 // module failed to load and should be ignored
-    next                  *_ModuleData
-}
-
-type _FindFuncBucket struct {
-    idx        uint32
-    subbuckets [16]byte
-}
-
-var findFuncTab = &_FindFuncBucket {
-    idx: 1,
-}
-
-func registerFunction(name string, pc uintptr, textSize uintptr, fp int, args int, size uintptr, argPtrs []bool, localPtrs []bool) {
-    mod := new(_ModuleData)
-    minpc := pc
-    maxpc := pc + size
-
-    /* build the PC & line table */
-    pclnt := []byte {
-        0xfb, 0xff, 0xff, 0xff,     // magic   : 0xfffffffb
-        0,                          // pad1    : 0
-        0,                          // pad2    : 0
-        1,                          // minLC   : 1
-        4 << (^uintptr(0) >> 63),   // ptrSize : 4 << (^uintptr(0) >> 63)
-    }
-
-    // cache arg and local stackmap
-    argptrs, localptrs := cacheStackmap(argPtrs, localPtrs, mod)
-
-    /* add the function name */
-    noff := len(pclnt)
-    pclnt = append(append(pclnt, name...), 0)
-
-    /* add PCDATA */
-    pcsp := len(pclnt)
-    pclnt = append(pclnt, encodeVariant((fp + 1) << 1)...)
-    pclnt = append(pclnt, encodeVariant(int(size))...)
-
-    /* function entry */
-    fnv := _Func {
-        entry     : pc,
-        nameoff   : int32(noff),
-        args      : int32(args),
-        pcsp      : int32(pcsp),
-        nfuncdata : 2,
-        argptrs   : uintptr(argptrs),
-        localptrs : uintptr(localptrs),
-    }
-
-    /* align the func to 8 bytes */
-    if p := len(pclnt) % 8; p != 0 {
-        pclnt = append(pclnt, make([]byte, 8 - p)...)
-    }
-
-    /* add the function descriptor */
-    foff := len(pclnt)
-    pclnt = append(pclnt, (*(*[unsafe.Sizeof(_Func{})]byte)(unsafe.Pointer(&fnv)))[:]...)
-
-    /* function table */
-    tab := []_FuncTab {
-        {entry: pc, funcoff: uintptr(foff)},
-        {entry: pc, funcoff: uintptr(foff)},
-        {entry: maxpc},
-    }
-
-    /* module data */
-    *mod = _ModuleData {
-        pclntable   : pclnt,
-        ftab        : tab,
-        findfunctab : findFuncTab,
-        minpc       : minpc,
-        maxpc       : maxpc,
-        modulename  : name,
-        gcdata: uintptr(unsafe.Pointer(&emptyByte)),
-        gcbss: uintptr(unsafe.Pointer(&emptyByte)),
-    }
-
-    /* verify and register the new module */
-    moduledataverify1(mod)
-    registerModule(mod)
-}

vendor/github.com/bytedance/sonic/internal/loader/funcdata_go116.go

@@ -1,175 +0,0 @@
-//go:build go1.16 && !go1.18
-// +build go1.16,!go1.18
-
-/*
- * Copyright 2021 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 (
-    `unsafe`
-)
-
-type _Func struct {
-    entry       uintptr // start pc
-    nameoff     int32   // function name
-    args        int32   // in/out args size
-    deferreturn uint32  // offset of start of a deferreturn call instruction from entry, if any.
-    pcsp        uint32
-    pcfile      uint32
-    pcln        uint32
-    npcdata     uint32
-    cuOffset    uint32  // runtime.cutab offset of this function's CU
-    funcID      uint8   // set for certain special runtime functions
-    _           [2]byte // pad
-    nfuncdata   uint8   // must be last
-    argptrs     uintptr
-    localptrs   uintptr
-}
-
-type _FuncTab struct {
-    entry   uintptr
-    funcoff uintptr
-}
-
-type _PCHeader struct {
-    magic          uint32  // 0xFFFFFFFA
-    pad1, pad2     uint8   // 0,0
-    minLC          uint8   // min instruction size
-    ptrSize        uint8   // size of a ptr in bytes
-    nfunc          int     // number of functions in the module
-    nfiles         uint    // number of entries in the file tab.
-    funcnameOffset uintptr // offset to the funcnametab variable from _PCHeader
-    cuOffset       uintptr // offset to the cutab variable from _PCHeader
-    filetabOffset  uintptr // offset to the filetab variable from _PCHeader
-    pctabOffset    uintptr // offset to the pctab varible from _PCHeader
-    pclnOffset     uintptr // offset to the pclntab variable from _PCHeader
-}
-
-type _BitVector struct {
-    n        int32 // # of bits
-    bytedata *uint8
-}
-
-type _PtabEntry struct {
-    name int32
-    typ  int32
-}
-
-type _TextSection struct {
-    vaddr    uintptr // prelinked section vaddr
-    length   uintptr // section length
-    baseaddr uintptr // relocated section address
-}
-
-type _ModuleData struct {
-    pcHeader              *_PCHeader
-    funcnametab           []byte
-    cutab                 []uint32
-    filetab               []byte
-    pctab                 []byte
-    pclntable             []_Func
-    ftab                  []_FuncTab
-    findfunctab           *_FindFuncBucket
-    minpc, maxpc          uintptr
-    text, etext           uintptr
-    noptrdata, enoptrdata uintptr
-    data, edata           uintptr
-    bss, ebss             uintptr
-    noptrbss, enoptrbss   uintptr
-    end, gcdata, gcbss    uintptr
-    types, etypes         uintptr
-    textsectmap           []_TextSection
-    typelinks             []int32
-    itablinks             []unsafe.Pointer
-    ptab                  []_PtabEntry
-    pluginpath            string
-    pkghashes             []struct{}
-    modulename            string
-    modulehashes          []struct{}
-    hasmain               uint8
-    gcdatamask, gcbssmask _BitVector
-    typemap               map[int32]unsafe.Pointer
-    bad                   bool
-    next                  *_ModuleData
-}
-
-type _FindFuncBucket struct {
-    idx        uint32
-    subbuckets [16]byte
-}
-
-var modHeader = &_PCHeader {
-    magic   : 0xfffffffa,
-    minLC   : 1,
-    nfunc   : 1,
-    ptrSize : 4 << (^uintptr(0) >> 63),
-}
-
-var findFuncTab = &_FindFuncBucket {
-    idx: 1,
-}
-
-func makePCtab(fp int) []byte {
-    return append([]byte{0}, encodeVariant((fp + 1) << 1)...)
-}
-
-func registerFunction(name string, pc uintptr, textSize uintptr, fp int, args int, size uintptr, argPtrs []bool, localPtrs []bool) {
-    mod := new(_ModuleData)
-    
-    minpc := pc
-    maxpc := pc + size
-
-    // cache arg and local stackmap
-    argptrs, localptrs := cacheStackmap(argPtrs, localPtrs, mod)
-
-    /* function entry */
-    lnt := []_Func {{
-        entry     : pc,
-        nameoff   : 1,
-        args      : int32(args),
-        pcsp      : 1,
-        nfuncdata : 2,
-        argptrs   : uintptr(argptrs),
-        localptrs : uintptr(localptrs),
-    }}
-
-    /* function table */
-    tab := []_FuncTab {
-        {entry: pc},
-        {entry: pc},
-        {entry: maxpc},
-    }
-
-    /* module data */
-    *mod = _ModuleData {
-        pcHeader    : modHeader,
-        funcnametab : append(append([]byte{0}, name...), 0),
-        pctab       : append(makePCtab(fp), encodeVariant(int(size))...),
-        pclntable   : lnt,
-        ftab        : tab,
-        findfunctab : findFuncTab,
-        minpc       : minpc,
-        maxpc       : maxpc,
-        modulename  : name,
-        gcdata: uintptr(unsafe.Pointer(&emptyByte)),
-        gcbss: uintptr(unsafe.Pointer(&emptyByte)),
-    }
-
-    /* verify and register the new module */
-    moduledataverify1(mod)
-    registerModule(mod)
-}

vendor/github.com/bytedance/sonic/internal/loader/funcdata_go118.go

@@ -1,201 +0,0 @@
-// +build go1.18,!go1.20
-
-/*
- * Copyright 2021 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 (
-    `unsafe`
-
-    `github.com/bytedance/sonic/internal/rt`
-)
-
-// A FuncFlag holds bits about a function.
-// This list must match the list in cmd/internal/objabi/funcid.go.
-type funcFlag uint8
-
-type _Func struct {
-    entryOff    uint32 // start pc
-    nameoff     int32   // function name
-    args        int32   // in/out args size
-    deferreturn uint32  // offset of start of a deferreturn call instruction from entry, if any.
-    pcsp        uint32
-    pcfile      uint32
-    pcln        uint32
-    npcdata     uint32
-    cuOffset    uint32  // runtime.cutab offset of this function's CU
-    funcID      uint8   // set for certain special runtime functions
-    flag        funcFlag
-    _           [1]byte // pad
-    nfuncdata   uint8   // must be last
-    argptrs     uint32
-    localptrs   uint32
-}
-
-type _FuncTab struct {
-    entry   uint32
-    funcoff uint32
-}
-
-type _PCHeader struct {
-    magic          uint32  // 0xFFFFFFF0
-    pad1, pad2     uint8   // 0,0
-    minLC          uint8   // min instruction size
-    ptrSize        uint8   // size of a ptr in bytes
-    nfunc          int     // number of functions in the module
-    nfiles         uint    // number of entries in the file tab
-    textStart      uintptr // base for function entry PC offsets in this module, equal to moduledata.text
-    funcnameOffset uintptr // offset to the funcnametab variable from pcHeader
-    cuOffset       uintptr // offset to the cutab variable from pcHeader
-    filetabOffset  uintptr // offset to the filetab variable from pcHeader
-    pctabOffset    uintptr // offset to the pctab variable from pcHeader
-    pclnOffset     uintptr // offset to the pclntab variable from pcHeader
-}
-
-type _BitVector struct {
-    n        int32 // # of bits
-    bytedata *uint8
-}
-
-type _PtabEntry struct {
-    name int32
-    typ  int32
-}
-
-type _TextSection struct {
-    vaddr    uintptr // prelinked section vaddr
-    length   uintptr // section length
-    baseaddr uintptr // relocated section address
-}
-
-type _ModuleData struct {
-    pcHeader              *_PCHeader
-    funcnametab           []byte
-    cutab                 []uint32
-    filetab               []byte
-    pctab                 []byte
-    pclntable             []byte
-    ftab                  []_FuncTab
-    findfunctab           *_FindFuncBucket
-    minpc, maxpc          uintptr
-    text, etext           uintptr
-    noptrdata, enoptrdata uintptr
-    data, edata           uintptr
-    bss, ebss             uintptr
-    noptrbss, enoptrbss   uintptr
-    end, gcdata, gcbss    uintptr
-    types, etypes         uintptr
-    rodata                uintptr
-    gofunc                uintptr 
-    textsectmap           []_TextSection
-    typelinks             []int32
-    itablinks             []unsafe.Pointer
-    ptab                  []_PtabEntry
-    pluginpath            string
-    pkghashes             []struct{}
-    modulename            string
-    modulehashes          []struct{}
-    hasmain               uint8
-    gcdatamask, gcbssmask _BitVector
-    typemap               map[int32]unsafe.Pointer
-    bad                   bool
-    next                  *_ModuleData
-}
-
-
-type _FindFuncBucket struct {
-    idx        uint32
-    subbuckets [16]byte
-}
-
-
-
-func makePCtab(fp int) []byte {
-    return append([]byte{0}, encodeVariant((fp + 1) << 1)...)
-}
-
-func registerFunction(name string, pc uintptr, textSize uintptr, fp int, args int, size uintptr, argPtrs []bool, localPtrs []bool) {
-    mod := new(_ModuleData)
-
-    minpc := pc
-    maxpc := pc + size
-
-    findFuncTab := make([]_FindFuncBucket, textSize/4096 + 1)
-
-    modHeader := &_PCHeader {
-        magic   : 0xfffffff0,
-        minLC   : 1,
-        nfunc   : 1,
-        ptrSize : 4 << (^uintptr(0) >> 63),
-        textStart: minpc,
-    }
-
-    // cache arg and local stackmap
-    argptrs, localptrs := cacheStackmap(argPtrs, localPtrs, mod)
-
-    base := argptrs
-    if argptrs > localptrs {
-        base = localptrs
-    }
-
-    /* function entry */
-    lnt := []_Func {{
-        entryOff  : 0,
-        nameoff   : 1,
-        args      : int32(args),
-        pcsp      : 1,
-        nfuncdata : 2,
-        argptrs: uint32(argptrs - base),
-        localptrs: uint32(localptrs - base),
-    }}
-    nlnt := len(lnt)*int(unsafe.Sizeof(_Func{}))
-    plnt := unsafe.Pointer(&lnt[0])
-
-    /* function table */
-    ftab := []_FuncTab {
-        {entry   : 0, funcoff : 16},    
-        {entry   : uint32(size)},
-    }
-    nftab := len(ftab)*int(unsafe.Sizeof(_FuncTab{}))
-    pftab := unsafe.Pointer(&ftab[0])
-
-    pclntab := make([]byte, 0, nftab + nlnt)
-    pclntab = append(pclntab, rt.BytesFrom(pftab, nftab, nftab)...)
-    pclntab = append(pclntab, rt.BytesFrom(plnt, nlnt, nlnt)...)
-
-    /* module data */
-    *mod = _ModuleData {
-        pcHeader    : modHeader,
-        funcnametab : append(append([]byte{0}, name...), 0),
-        pctab       : append(makePCtab(fp), encodeVariant(int(size))...),
-        pclntable   : pclntab,
-        ftab        : ftab,
-        text        : minpc,
-        etext       : pc + textSize,
-        findfunctab : &findFuncTab[0],
-        minpc       : minpc,
-        maxpc       : maxpc,
-        modulename  : name,
-        gcdata: uintptr(unsafe.Pointer(&emptyByte)),
-        gcbss: uintptr(unsafe.Pointer(&emptyByte)),
-        gofunc: base,
-    }
-
-    /* verify and register the new module */
-    moduledataverify1(mod)
-    registerModule(mod)
-}

vendor/github.com/bytedance/sonic/internal/loader/funcdata_go120.go

@@ -1,201 +0,0 @@
-// +build go1.20
-
-/*
- * Copyright 2021 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 (
-    `unsafe`
-
-    `github.com/bytedance/sonic/internal/rt`
-)
-
-// A FuncFlag holds bits about a function.
-// This list must match the list in cmd/internal/objabi/funcid.go.
-type funcFlag uint8
-
-type _Func struct {
-    entryOff    uint32 // start pc
-    nameoff     int32   // function name
-    args        int32   // in/out args size
-    deferreturn uint32  // offset of start of a deferreturn call instruction from entry, if any.
-    pcsp        uint32
-    pcfile      uint32
-    pcln        uint32
-    npcdata     uint32
-    cuOffset    uint32  // runtime.cutab offset of this function's CU
-    funcID      uint8   // set for certain special runtime functions
-    flag        funcFlag
-    _           [1]byte // pad
-    nfuncdata   uint8   // must be last
-    argptrs     uint32
-    localptrs   uint32
-}
-
-type _FuncTab struct {
-    entry   uint32
-    funcoff uint32
-}
-
-type _PCHeader struct {
-    magic          uint32  // 0xFFFFFFF0
-    pad1, pad2     uint8   // 0,0
-    minLC          uint8   // min instruction size
-    ptrSize        uint8   // size of a ptr in bytes
-    nfunc          int     // number of functions in the module
-    nfiles         uint    // number of entries in the file tab
-    textStart      uintptr // base for function entry PC offsets in this module, equal to moduledata.text
-    funcnameOffset uintptr // offset to the funcnametab variable from pcHeader
-    cuOffset       uintptr // offset to the cutab variable from pcHeader
-    filetabOffset  uintptr // offset to the filetab variable from pcHeader
-    pctabOffset    uintptr // offset to the pctab variable from pcHeader
-    pclnOffset     uintptr // offset to the pclntab variable from pcHeader
-}
-
-type _BitVector struct {
-    n        int32 // # of bits
-    bytedata *uint8
-}
-
-type _PtabEntry struct {
-    name int32
-    typ  int32
-}
-
-type _TextSection struct {
-    vaddr    uintptr // prelinked section vaddr
-    length   uintptr // section length
-    baseaddr uintptr // relocated section address
-}
-
-type _ModuleData struct {
-    pcHeader              *_PCHeader
-    funcnametab           []byte
-    cutab                 []uint32
-    filetab               []byte
-    pctab                 []byte
-    pclntable             []byte
-    ftab                  []_FuncTab
-    findfunctab           *_FindFuncBucket
-    minpc, maxpc          uintptr
-    text, etext           uintptr
-    noptrdata, enoptrdata uintptr
-    data, edata           uintptr
-    bss, ebss             uintptr
-    noptrbss, enoptrbss   uintptr
-    end, gcdata, gcbss    uintptr
-    types, etypes         uintptr
-    rodata                uintptr
-    gofunc                uintptr 
-    textsectmap           []_TextSection
-    typelinks             []int32
-    itablinks             []unsafe.Pointer
-    ptab                  []_PtabEntry
-    pluginpath            string
-    pkghashes             []struct{}
-    modulename            string
-    modulehashes          []struct{}
-    hasmain               uint8
-    gcdatamask, gcbssmask _BitVector
-    typemap               map[int32]unsafe.Pointer
-    bad                   bool
-    next                  *_ModuleData
-}
-
-
-type _FindFuncBucket struct {
-    idx        uint32
-    subbuckets [16]byte
-}
-
-
-
-func makePCtab(fp int) []byte {
-    return append([]byte{0}, encodeVariant((fp + 1) << 1)...)
-}
-
-func registerFunction(name string, pc uintptr, textSize uintptr, fp int, args int, size uintptr, argPtrs []bool, localPtrs []bool) {
-    mod := new(_ModuleData)
-
-    minpc := pc
-    maxpc := pc + size
-
-    findFuncTab := make([]_FindFuncBucket, textSize/4096 + 1)
-
-    modHeader := &_PCHeader {
-        magic   : 0xfffffff0,
-        minLC   : 1,
-        nfunc   : 1,
-        ptrSize : 4 << (^uintptr(0) >> 63),
-        textStart: minpc,
-    }
-
-    // cache arg and local stackmap
-    argptrs, localptrs := cacheStackmap(argPtrs, localPtrs, mod)
-
-    base := argptrs
-    if argptrs > localptrs {
-        base = localptrs
-    }
-
-    /* function entry */
-    lnt := []_Func {{
-        entryOff  : 0,
-        nameoff   : 1,
-        args      : int32(args),
-        pcsp      : 1,
-        nfuncdata : 2,
-        argptrs: uint32(argptrs - base),
-        localptrs: uint32(localptrs - base),
-    }}
-    nlnt := len(lnt)*int(unsafe.Sizeof(_Func{}))
-    plnt := unsafe.Pointer(&lnt[0])
-
-    /* function table */
-    ftab := []_FuncTab {
-        {entry   : 0, funcoff : 16},    
-        {entry   : uint32(size)},
-    }
-    nftab := len(ftab)*int(unsafe.Sizeof(_FuncTab{}))
-    pftab := unsafe.Pointer(&ftab[0])
-
-    pclntab := make([]byte, 0, nftab + nlnt)
-    pclntab = append(pclntab, rt.BytesFrom(pftab, nftab, nftab)...)
-    pclntab = append(pclntab, rt.BytesFrom(plnt, nlnt, nlnt)...)
-
-    /* module data */
-    *mod = _ModuleData {
-        pcHeader    : modHeader,
-        funcnametab : append(append([]byte{0}, name...), 0),
-        pctab       : append(makePCtab(fp), encodeVariant(int(size))...),
-        pclntable   : pclntab,
-        ftab        : ftab,
-        text        : minpc,
-        etext       : pc + textSize,
-        findfunctab : &findFuncTab[0],
-        minpc       : minpc,
-        maxpc       : maxpc,
-        modulename  : name,
-        gcdata: uintptr(unsafe.Pointer(&emptyByte)),
-        gcbss: uintptr(unsafe.Pointer(&emptyByte)),
-        gofunc: base,
-    }
-
-    /* verify and register the new module */
-    moduledataverify1(mod)
-    registerModule(mod)
-}

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

@@ -1,74 +0,0 @@
-//go:build darwin || linux
-// +build darwin linux
-
-/*
- * Copyright 2021 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 (
-    `fmt`
-    `os`
-    `reflect`
-    `syscall`
-    `unsafe`
-)
-
-const (
-    _AP = syscall.MAP_ANON  | syscall.MAP_PRIVATE
-    _RX = syscall.PROT_READ | syscall.PROT_EXEC
-    _RW = syscall.PROT_READ | syscall.PROT_WRITE
-)
-
-type Loader   []byte
-type Function unsafe.Pointer
-
-func (self Loader) Load(fn string, fp int, args int, argPtrs []bool, localPtrs []bool) (f Function) {
-    p := os.Getpagesize()
-    n := (((len(self) - 1) / p) + 1) * p
-
-    /* register the function */
-    m := mmap(n)
-    v := fmt.Sprintf("runtime.__%s_%x", fn, m)
-    
-    registerFunction(v, m, uintptr(n), fp, args, uintptr(len(self)), argPtrs, localPtrs)
-
-    /* reference as a slice */
-    s := *(*[]byte)(unsafe.Pointer(&reflect.SliceHeader {
-        Data : m,
-        Cap  : n,
-        Len  : len(self),
-    }))
-
-    /* copy the machine code, and make it executable */
-    copy(s, self)
-    mprotect(m, n)
-    return Function(&m)
-}
-
-func mmap(nb int) uintptr {
-    if m, _, e := syscall.RawSyscall6(syscall.SYS_MMAP, 0, uintptr(nb), _RW, _AP, 0, 0); e != 0 {
-        panic(e)
-    } else {
-        return m
-    }
-}
-
-func mprotect(p uintptr, nb int) {
-    if _, _, err := syscall.RawSyscall(syscall.SYS_MPROTECT, p, uintptr(nb), _RX); err != 0 {
-        panic(err)
-    }
-}

vendor/github.com/bytedance/sonic/internal/loader/loader_windows.go

@@ -1,111 +0,0 @@
-//go:build windows
-// +build windows
-
-/*
- * Copyright 2021 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 (
-    `fmt`
-    `os`
-    `reflect`
-    `syscall`
-    `unsafe`
-)
-
-const (
-    MEM_COMMIT  = 0x00001000
-    MEM_RESERVE = 0x00002000
-)
-
-var (
-    libKernel32                = syscall.NewLazyDLL("KERNEL32.DLL")
-    libKernel32_VirtualAlloc   = libKernel32.NewProc("VirtualAlloc")
-    libKernel32_VirtualProtect = libKernel32.NewProc("VirtualProtect")
-)
-
-type Loader   []byte
-type Function unsafe.Pointer
-
-func (self Loader) Load(fn string, fp int, args int, argPtrs []bool, localPtrs []bool) (f Function) {
-    p := os.Getpagesize()
-    n := (((len(self) - 1) / p) + 1) * p
-
-    /* register the function */
-    m := mmap(n)
-    v := fmt.Sprintf("runtime.__%s_%x", fn, m)
-    
-    registerFunction(v, m, uintptr(n), fp, args, uintptr(len(self)), argPtrs, localPtrs)
-
-    /* reference as a slice */
-    s := *(*[]byte)(unsafe.Pointer(&reflect.SliceHeader {
-        Data : m,
-        Cap  : n,
-        Len  : len(self),
-    }))
-
-    /* copy the machine code, and make it executable */
-    copy(s, self)
-    mprotect(m, n)
-    return Function(&m)
-}
-
-func mmap(nb int) uintptr {
-    addr, err := winapi_VirtualAlloc(0, nb, MEM_COMMIT|MEM_RESERVE, syscall.PAGE_READWRITE)
-    if err != nil {
-        panic(err)
-    }
-    return addr
-}
-
-func mprotect(p uintptr, nb int) (oldProtect int) {
-    err := winapi_VirtualProtect(p, nb, syscall.PAGE_EXECUTE_READ, &oldProtect)
-    if err != nil {
-        panic(err)
-    }
-    return
-}
-
-// winapi_VirtualAlloc allocate memory
-// Doc: https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualalloc
-func winapi_VirtualAlloc(lpAddr uintptr, dwSize int, flAllocationType int, flProtect int) (uintptr, error) {
-    r1, _, err := libKernel32_VirtualAlloc.Call(
-        lpAddr,
-        uintptr(dwSize),
-        uintptr(flAllocationType),
-        uintptr(flProtect),
-    )
-    if r1 == 0 {
-        return 0, err
-    }
-    return r1, nil
-}
-
-// winapi_VirtualProtect change memory protection
-// Doc: https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualprotect
-func winapi_VirtualProtect(lpAddr uintptr, dwSize int, flNewProtect int, lpflOldProtect *int) error {
-    r1, _, err := libKernel32_VirtualProtect.Call(
-        lpAddr,
-        uintptr(dwSize),
-        uintptr(flNewProtect),
-        uintptr(unsafe.Pointer(lpflOldProtect)),
-    )
-    if r1 == 0 {
-        return err
-    }
-    return nil
-}

vendor/github.com/bytedance/sonic/internal/native/avx/native_amd64.go

@@ -1,5 +1,7 @@
 // Code generated by Makefile, DO NOT EDIT.
 
+// Code generated by Makefile, DO NOT EDIT.
+
 /*
  * Copyright 2021 ByteDance Inc.
  *
@@ -22,114 +24,168 @@ import (
     `unsafe`
 
     `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+var (
+    __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)
+
+    __lspace func(sp unsafe.Pointer, nb int, off int) (ret int)
+
+    __quote func(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn unsafe.Pointer, flags uint64) (ret int)
+
+    __html_escape func(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn unsafe.Pointer) (ret int)
+
+    __unquote func(sp unsafe.Pointer, nb int, dp unsafe.Pointer, ep unsafe.Pointer, flags uint64) (ret int)
+
+    __value func(s unsafe.Pointer, n int, p int, v unsafe.Pointer, flags uint64) (ret int)
+
+    __vstring func(s unsafe.Pointer, p unsafe.Pointer, v unsafe.Pointer, flags uint64)
+
+    __vnumber func(s unsafe.Pointer, p unsafe.Pointer, v unsafe.Pointer)
+
+    __vsigned func(s unsafe.Pointer, p unsafe.Pointer, v unsafe.Pointer)
+
+    __vunsigned func(s unsafe.Pointer, p unsafe.Pointer, v unsafe.Pointer)
+
+    __skip_one func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer, flags uint64) (ret int)
+
+    __skip_one_fast func(s unsafe.Pointer, p unsafe.Pointer) (ret int)
+
+    __skip_array func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer, flags uint64) (ret int)
+
+    __skip_object func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer, flags uint64) (ret int)
+
+    __skip_number func(s unsafe.Pointer, p unsafe.Pointer) (ret int)
+
+    __validate_one func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer) (ret int)
+
+    __get_by_path func(s unsafe.Pointer, p unsafe.Pointer, path unsafe.Pointer, m unsafe.Pointer) (ret int)
+
+    __validate_utf8 func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer) (ret int)
+
+    __validate_utf8_fast func(s unsafe.Pointer)  (ret int)
+
+    __fsm_exec func(m unsafe.Pointer, s unsafe.Pointer, p unsafe.Pointer, flags uint64) (ret int)
 )
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __i64toa(out *byte, val int64) (ret int)
+func i64toa(out *byte, val int64) (ret int) {
+    return __i64toa(rt.NoEscape(unsafe.Pointer(out)), val)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __u64toa(out *byte, val uint64) (ret int)
+func u64toa(out *byte, val uint64) (ret int) {
+    return __u64toa(rt.NoEscape(unsafe.Pointer(out)), val)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __f64toa(out *byte, val float64) (ret int)
+func f64toa(out *byte, val float64) (ret int) {
+    return __f64toa(rt.NoEscape(unsafe.Pointer(out)), val)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __f32toa(out *byte, val float32) (ret int)
+func f32toa(out *byte, val float32) (ret int) {
+    return __f32toa(rt.NoEscape(unsafe.Pointer(out)), val)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __lspace(sp unsafe.Pointer, nb int, off int) (ret int)
+func lspace(sp unsafe.Pointer, nb int, off int) (ret int) {
+    return __lspace(rt.NoEscape(sp), nb, off)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __quote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int, flags uint64) (ret int)
+func quote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int, flags uint64) (ret int) {
+    return __quote(rt.NoEscape(unsafe.Pointer(sp)), nb, rt.NoEscape(unsafe.Pointer(dp)), rt.NoEscape(unsafe.Pointer(dn)), flags)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __html_escape(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int) (ret int)
+func html_escape(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int) (ret int) {
+    return __html_escape(rt.NoEscape(unsafe.Pointer(sp)), nb, rt.NoEscape(unsafe.Pointer(dp)), rt.NoEscape(unsafe.Pointer(dn)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __unquote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, ep *int, flags uint64) (ret int)
+func unquote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, ep *int, flags uint64) (ret int) {
+    return __unquote(rt.NoEscape(unsafe.Pointer(sp)), nb, rt.NoEscape(unsafe.Pointer(dp)), rt.NoEscape(unsafe.Pointer(ep)), flags)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __value(s unsafe.Pointer, n int, p int, v *types.JsonState, flags uint64) (ret int)
+func value(s unsafe.Pointer, n int, p int, v *types.JsonState, flags uint64) (ret int) {
+    return __value(rt.NoEscape(unsafe.Pointer(s)), n, p, rt.NoEscape(unsafe.Pointer(v)), flags)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __vstring(s *string, p *int, v *types.JsonState, flags uint64)
+func vstring(s *string, p *int, v *types.JsonState, flags uint64) {
+    __vstring(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(v)), flags)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __vnumber(s *string, p *int, v *types.JsonState)
+func vnumber(s *string, p *int, v *types.JsonState) {
+    __vnumber(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(v)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __vsigned(s *string, p *int, v *types.JsonState)
+func vsigned(s *string, p *int, v *types.JsonState) {
+    __vsigned(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(v)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __vunsigned(s *string, p *int, v *types.JsonState)
+func vunsigned(s *string, p *int, v *types.JsonState) {
+    __vunsigned(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(v)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __skip_one(s *string, p *int, m *types.StateMachine, flags uint64) (ret int)
+func skip_one(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) {
+    return __skip_one(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)), flags)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __skip_one_fast(s *string, p *int) (ret int)
+func skip_one_fast(s *string, p *int) (ret int) {
+    return __skip_one_fast(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __skip_array(s *string, p *int, m *types.StateMachine, flags uint64) (ret int)
+func skip_array(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) {
+    return __skip_array(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)), flags)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __skip_object(s *string, p *int, m *types.StateMachine, flags uint64) (ret int)
+func skip_object(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) {
+    return __skip_object(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)), flags)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __skip_number(s *string, p *int) (ret int)
+func skip_number(s *string, p *int) (ret int) {
+    return __skip_number(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __validate_one(s *string, p *int, m *types.StateMachine) (ret int)
+func validate_one(s *string, p *int, m *types.StateMachine) (ret int) {
+    return __validate_one(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __get_by_path(s *string, p *int, path *[]interface{}, m *types.StateMachine) (ret int)
+func get_by_path(s *string, p *int, path *[]interface{}, m *types.StateMachine) (ret int) {
+    return __get_by_path(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(path)), rt.NoEscape(unsafe.Pointer(m)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __validate_utf8(s *string, p *int, m *types.StateMachine) (ret int)
+func validate_utf8(s *string, p *int, m *types.StateMachine) (ret int) {
+    return __validate_utf8(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __validate_utf8_fast(s *string)  (ret int)
+func validate_utf8_fast(s *string)  (ret int) {
+    return __validate_utf8_fast(rt.NoEscape(unsafe.Pointer(s)))
+}
+
+//go:nosplit
+func fsm_exec(m *types.StateMachine, s *string, p *int, flags uint64) (ret int) {
+    return __fsm_exec(rt.NoEscape(unsafe.Pointer(m)), rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), flags)
+}

vendor/github.com/bytedance/sonic/internal/native/avx/native_export_amd64.go

@@ -1,49 +0,0 @@
-// Code generated by Makefile, DO NOT EDIT.
-
-/*
- * Copyright 2021 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 avx
-
-var (
-    S_f64toa = _subr__f64toa
-    S_f32toa = _subr__f32toa
-    S_i64toa = _subr__i64toa
-    S_u64toa = _subr__u64toa
-    S_lspace = _subr__lspace
-)
-
-var (
-    S_quote   = _subr__quote
-    S_unquote = _subr__unquote
-)
-
-var (
-    S_value     = _subr__value
-    S_vstring   = _subr__vstring
-    S_vnumber   = _subr__vnumber
-    S_vsigned   = _subr__vsigned
-    S_vunsigned = _subr__vunsigned
-)
-
-var (
-    S_skip_one    = _subr__skip_one
-    S_skip_one_fast = _subr__skip_one_fast
-    S_skip_array  = _subr__skip_array
-    S_skip_object = _subr__skip_object
-    S_skip_number = _subr__skip_number
-    S_get_by_path = _subr__get_by_path
-)

vendor/github.com/bytedance/sonic/internal/native/avx/native_subr_amd64.go

@@ -3,107 +3,601 @@
 
 package avx
 
-//go:nosplit
-//go:noescape
-//goland:noinspection ALL
-func __native_entry__() uintptr
+import (
+	`github.com/bytedance/sonic/loader`
+)
 
-var (
-    _subr__f32toa             = __native_entry__() + 31264
-    _subr__f64toa             = __native_entry__() + 192
-    _subr__get_by_path        = __native_entry__() + 25856
-    _subr__html_escape        = __native_entry__() + 9040
-    _subr__i64toa             = __native_entry__() + 3488
-    _subr__lspace             = __native_entry__() + 16
-    _subr__quote              = __native_entry__() + 4880
-    _subr__skip_array         = __native_entry__() + 17952
-    _subr__skip_number        = __native_entry__() + 21952
-    _subr__skip_object        = __native_entry__() + 20368
-    _subr__skip_one           = __native_entry__() + 22112
-    _subr__skip_one_fast      = __native_entry__() + 22352
-    _subr__u64toa             = __native_entry__() + 3600
-    _subr__unquote            = __native_entry__() + 6672
-    _subr__validate_one       = __native_entry__() + 22176
-    _subr__validate_utf8      = __native_entry__() + 30000
-    _subr__validate_utf8_fast = __native_entry__() + 30672
-    _subr__value              = __native_entry__() + 12224
-    _subr__vnumber            = __native_entry__() + 15616
-    _subr__vsigned            = __native_entry__() + 17232
-    _subr__vstring            = __native_entry__() + 14064
-    _subr__vunsigned          = __native_entry__() + 17600
+const (
+    _entry__f32toa = 31136
+    _entry__f64toa = 192
+    _entry__format_significand = 35248
+    _entry__format_integer = 3040
+    _entry__fsm_exec = 17920
+    _entry__advance_string = 14320
+    _entry__advance_string_default = 36640
+    _entry__do_skip_number = 20528
+    _entry__get_by_path = 25680
+    _entry__skip_one_fast = 22160
+    _entry__html_escape = 8912
+    _entry__i64toa = 3472
+    _entry__u64toa = 3584
+    _entry__lspace = 16
+    _entry__quote = 4864
+    _entry__skip_array = 17872
+    _entry__skip_number = 21792
+    _entry__skip_object = 20160
+    _entry__skip_one = 21936
+    _entry__unquote = 6576
+    _entry__validate_one = 21984
+    _entry__validate_utf8 = 29888
+    _entry__validate_utf8_fast = 30560
+    _entry__value = 12320
+    _entry__vnumber = 15648
+    _entry__atof_eisel_lemire64 = 10160
+    _entry__atof_native = 11712
+    _entry__decimal_to_f64 = 10528
+    _entry__right_shift = 36208
+    _entry__left_shift = 35712
+    _entry__vsigned = 17200
+    _entry__vstring = 14144
+    _entry__vunsigned = 17520
 )
 
 const (
     _stack__f32toa = 48
     _stack__f64toa = 80
-    _stack__get_by_path = 304
-    _stack__html_escape = 64
+    _stack__format_significand = 24
+    _stack__format_integer = 16
+    _stack__fsm_exec = 168
+    _stack__advance_string = 64
+    _stack__advance_string_default = 64
+    _stack__do_skip_number = 48
+    _stack__get_by_path = 280
+    _stack__skip_one_fast = 176
+    _stack__html_escape = 72
     _stack__i64toa = 16
+    _stack__u64toa = 8
     _stack__lspace = 8
     _stack__quote = 56
-    _stack__skip_array = 128
-    _stack__skip_number = 72
-    _stack__skip_object = 128
-    _stack__skip_one = 128
-    _stack__skip_one_fast = 200
-    _stack__u64toa = 8
+    _stack__skip_array = 176
+    _stack__skip_number = 88
+    _stack__skip_object = 176
+    _stack__skip_one = 176
     _stack__unquote = 88
-    _stack__validate_one = 128
+    _stack__validate_one = 176
     _stack__validate_utf8 = 48
     _stack__validate_utf8_fast = 24
     _stack__value = 328
     _stack__vnumber = 240
+    _stack__atof_eisel_lemire64 = 32
+    _stack__atof_native = 136
+    _stack__decimal_to_f64 = 80
+    _stack__right_shift = 8
+    _stack__left_shift = 24
     _stack__vsigned = 16
-    _stack__vstring = 136
-    _stack__vunsigned = 16
-)
-
-var (
-    _ = _subr__f32toa
-    _ = _subr__f64toa
-    _ = _subr__get_by_path
-    _ = _subr__html_escape
-    _ = _subr__i64toa
-    _ = _subr__lspace
-    _ = _subr__quote
-    _ = _subr__skip_array
-    _ = _subr__skip_number
-    _ = _subr__skip_object
-    _ = _subr__skip_one
-    _ = _subr__skip_one_fast
-    _ = _subr__u64toa
-    _ = _subr__unquote
-    _ = _subr__validate_one
-    _ = _subr__validate_utf8
-    _ = _subr__validate_utf8_fast
-    _ = _subr__value
-    _ = _subr__vnumber
-    _ = _subr__vsigned
-    _ = _subr__vstring
-    _ = _subr__vunsigned
+    _stack__vstring = 120
+    _stack__vunsigned = 8
 )
 
 const (
-    _ = _stack__f32toa
-    _ = _stack__f64toa
-    _ = _stack__get_by_path
-    _ = _stack__html_escape
-    _ = _stack__i64toa
-    _ = _stack__lspace
-    _ = _stack__quote
-    _ = _stack__skip_array
-    _ = _stack__skip_number
-    _ = _stack__skip_object
-    _ = _stack__skip_one
-    _ = _stack__skip_one_fast
-    _ = _stack__u64toa
-    _ = _stack__unquote
-    _ = _stack__validate_one
-    _ = _stack__validate_utf8
-    _ = _stack__validate_utf8_fast
-    _ = _stack__value
-    _ = _stack__vnumber
-    _ = _stack__vsigned
-    _ = _stack__vstring
-    _ = _stack__vunsigned
+    _size__f32toa = 3392
+    _size__f64toa = 2848
+    _size__format_significand = 464
+    _size__format_integer = 432
+    _size__fsm_exec = 1692
+    _size__advance_string = 1280
+    _size__advance_string_default = 944
+    _size__do_skip_number = 924
+    _size__get_by_path = 4208
+    _size__skip_one_fast = 3016
+    _size__html_escape = 1248
+    _size__i64toa = 48
+    _size__u64toa = 1232
+    _size__lspace = 144
+    _size__quote = 1696
+    _size__skip_array = 48
+    _size__skip_number = 144
+    _size__skip_object = 48
+    _size__skip_one = 48
+    _size__unquote = 2272
+    _size__validate_one = 48
+    _size__validate_utf8 = 672
+    _size__validate_utf8_fast = 544
+    _size__value = 1316
+    _size__vnumber = 1552
+    _size__atof_eisel_lemire64 = 368
+    _size__atof_native = 608
+    _size__decimal_to_f64 = 1184
+    _size__right_shift = 400
+    _size__left_shift = 496
+    _size__vsigned = 320
+    _size__vstring = 128
+    _size__vunsigned = 336
 )
+
+var (
+    _pcsp__f32toa = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {3350, 48},
+        {3351, 40},
+        {3353, 32},
+        {3355, 24},
+        {3357, 16},
+        {3359, 8},
+        {3363, 0},
+        {3385, 48},
+    }
+    _pcsp__f64toa = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {2788, 56},
+        {2792, 48},
+        {2793, 40},
+        {2795, 32},
+        {2797, 24},
+        {2799, 16},
+        {2801, 8},
+        {2805, 0},
+        {2843, 56},
+    }
+    _pcsp__format_significand = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {452, 24},
+        {453, 16},
+        {455, 8},
+        {457, 0},
+    }
+    _pcsp__format_integer = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {412, 16},
+        {413, 8},
+        {414, 0},
+        {423, 16},
+        {424, 8},
+        {426, 0},
+    }
+    _pcsp__fsm_exec = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {1342, 104},
+        {1346, 48},
+        {1347, 40},
+        {1349, 32},
+        {1351, 24},
+        {1353, 16},
+        {1355, 8},
+        {1356, 0},
+        {1692, 104},
+    }
+    _pcsp__advance_string = [][2]uint32{
+        {14, 0},
+        {18, 8},
+        {20, 16},
+        {22, 24},
+        {24, 32},
+        {26, 40},
+        {27, 48},
+        {557, 56},
+        {561, 48},
+        {562, 40},
+        {564, 32},
+        {566, 24},
+        {568, 16},
+        {570, 8},
+        {571, 0},
+        {1268, 56},
+    }
+    _pcsp__advance_string_default = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {552, 64},
+        {556, 48},
+        {557, 40},
+        {559, 32},
+        {561, 24},
+        {563, 16},
+        {565, 8},
+        {566, 0},
+        {931, 64},
+    }
+    _pcsp__do_skip_number = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {849, 48},
+        {850, 40},
+        {852, 32},
+        {854, 24},
+        {856, 16},
+        {858, 8},
+        {859, 0},
+        {924, 48},
+    }
+    _pcsp__get_by_path = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {4012, 104},
+        {4016, 48},
+        {4017, 40},
+        {4019, 32},
+        {4021, 24},
+        {4023, 16},
+        {4025, 8},
+        {4026, 0},
+        {4194, 104},
+    }
+    _pcsp__skip_one_fast = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {658, 176},
+        {659, 168},
+        {661, 160},
+        {663, 152},
+        {665, 144},
+        {667, 136},
+        {671, 128},
+        {3016, 176},
+    }
+    _pcsp__html_escape = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {1224, 72},
+        {1228, 48},
+        {1229, 40},
+        {1231, 32},
+        {1233, 24},
+        {1235, 16},
+        {1237, 8},
+        {1239, 0},
+    }
+    _pcsp__i64toa = [][2]uint32{
+        {14, 0},
+        {34, 8},
+        {36, 0},
+    }
+    _pcsp__u64toa = [][2]uint32{
+        {1, 0},
+        {161, 8},
+        {162, 0},
+        {457, 8},
+        {458, 0},
+        {756, 8},
+        {757, 0},
+        {1221, 8},
+        {1223, 0},
+    }
+    _pcsp__lspace = [][2]uint32{
+        {1, 0},
+        {89, 8},
+        {90, 0},
+        {103, 8},
+        {104, 0},
+        {111, 8},
+        {113, 0},
+    }
+    _pcsp__quote = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {1649, 56},
+        {1653, 48},
+        {1654, 40},
+        {1656, 32},
+        {1658, 24},
+        {1660, 16},
+        {1662, 8},
+        {1663, 0},
+        {1690, 56},
+    }
+    _pcsp__skip_array = [][2]uint32{
+        {1, 0},
+        {28, 8},
+        {34, 0},
+    }
+    _pcsp__skip_number = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {100, 40},
+        {101, 32},
+        {103, 24},
+        {105, 16},
+        {107, 8},
+        {108, 0},
+        {139, 40},
+    }
+    _pcsp__skip_object = [][2]uint32{
+        {1, 0},
+        {28, 8},
+        {34, 0},
+    }
+    _pcsp__skip_one = [][2]uint32{
+        {1, 0},
+        {30, 8},
+        {36, 0},
+    }
+    _pcsp__unquote = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {1684, 88},
+        {1688, 48},
+        {1689, 40},
+        {1691, 32},
+        {1693, 24},
+        {1695, 16},
+        {1697, 8},
+        {1698, 0},
+        {2270, 88},
+    }
+    _pcsp__validate_one = [][2]uint32{
+        {1, 0},
+        {35, 8},
+        {41, 0},
+    }
+    _pcsp__validate_utf8 = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {11, 40},
+        {623, 48},
+        {627, 40},
+        {628, 32},
+        {630, 24},
+        {632, 16},
+        {634, 8},
+        {635, 0},
+        {666, 48},
+    }
+    _pcsp__validate_utf8_fast = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {5, 16},
+        {247, 24},
+        {251, 16},
+        {252, 8},
+        {253, 0},
+        {527, 24},
+        {531, 16},
+        {532, 8},
+        {534, 0},
+    }
+    _pcsp__value = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {495, 88},
+        {499, 48},
+        {500, 40},
+        {502, 32},
+        {504, 24},
+        {506, 16},
+        {508, 8},
+        {509, 0},
+        {1316, 88},
+    }
+    _pcsp__vnumber = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {803, 104},
+        {807, 48},
+        {808, 40},
+        {810, 32},
+        {812, 24},
+        {814, 16},
+        {816, 8},
+        {817, 0},
+        {1547, 104},
+    }
+    _pcsp__atof_eisel_lemire64 = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {292, 32},
+        {293, 24},
+        {295, 16},
+        {297, 8},
+        {298, 0},
+        {362, 32},
+    }
+    _pcsp__atof_native = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {587, 56},
+        {591, 8},
+        {593, 0},
+    }
+    _pcsp__decimal_to_f64 = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {1144, 56},
+        {1148, 48},
+        {1149, 40},
+        {1151, 32},
+        {1153, 24},
+        {1155, 16},
+        {1157, 8},
+        {1158, 0},
+        {1169, 56},
+    }
+    _pcsp__right_shift = [][2]uint32{
+        {1, 0},
+        {318, 8},
+        {319, 0},
+        {387, 8},
+        {388, 0},
+        {396, 8},
+        {398, 0},
+    }
+    _pcsp__left_shift = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {363, 24},
+        {364, 16},
+        {366, 8},
+        {367, 0},
+        {470, 24},
+        {471, 16},
+        {473, 8},
+        {474, 0},
+        {486, 24},
+    }
+    _pcsp__vsigned = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {112, 16},
+        {113, 8},
+        {114, 0},
+        {125, 16},
+        {126, 8},
+        {127, 0},
+        {260, 16},
+        {261, 8},
+        {262, 0},
+        {266, 16},
+        {267, 8},
+        {268, 0},
+        {306, 16},
+        {307, 8},
+        {308, 0},
+        {316, 16},
+        {317, 8},
+        {319, 0},
+    }
+    _pcsp__vstring = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {11, 40},
+        {105, 56},
+        {109, 40},
+        {110, 32},
+        {112, 24},
+        {114, 16},
+        {116, 8},
+        {118, 0},
+    }
+    _pcsp__vunsigned = [][2]uint32{
+        {1, 0},
+        {71, 8},
+        {72, 0},
+        {83, 8},
+        {84, 0},
+        {107, 8},
+        {108, 0},
+        {273, 8},
+        {274, 0},
+        {312, 8},
+        {313, 0},
+        {320, 8},
+        {322, 0},
+    }
+)
+
+var Funcs = []loader.CFunc{
+    {"__native_entry__", 0, 67, 0, nil},
+    {"_f32toa", _entry__f32toa, _size__f32toa, _stack__f32toa, _pcsp__f32toa},
+    {"_f64toa", _entry__f64toa, _size__f64toa, _stack__f64toa, _pcsp__f64toa},
+    {"_format_significand", _entry__format_significand, _size__format_significand, _stack__format_significand, _pcsp__format_significand},
+    {"_format_integer", _entry__format_integer, _size__format_integer, _stack__format_integer, _pcsp__format_integer},
+    {"_fsm_exec", _entry__fsm_exec, _size__fsm_exec, _stack__fsm_exec, _pcsp__fsm_exec},
+    {"_advance_string", _entry__advance_string, _size__advance_string, _stack__advance_string, _pcsp__advance_string},
+    {"_advance_string_default", _entry__advance_string_default, _size__advance_string_default, _stack__advance_string_default, _pcsp__advance_string_default},
+    {"_do_skip_number", _entry__do_skip_number, _size__do_skip_number, _stack__do_skip_number, _pcsp__do_skip_number},
+    {"_get_by_path", _entry__get_by_path, _size__get_by_path, _stack__get_by_path, _pcsp__get_by_path},
+    {"_skip_one_fast", _entry__skip_one_fast, _size__skip_one_fast, _stack__skip_one_fast, _pcsp__skip_one_fast},
+    {"_html_escape", _entry__html_escape, _size__html_escape, _stack__html_escape, _pcsp__html_escape},
+    {"_i64toa", _entry__i64toa, _size__i64toa, _stack__i64toa, _pcsp__i64toa},
+    {"_u64toa", _entry__u64toa, _size__u64toa, _stack__u64toa, _pcsp__u64toa},
+    {"_lspace", _entry__lspace, _size__lspace, _stack__lspace, _pcsp__lspace},
+    {"_quote", _entry__quote, _size__quote, _stack__quote, _pcsp__quote},
+    {"_skip_array", _entry__skip_array, _size__skip_array, _stack__skip_array, _pcsp__skip_array},
+    {"_skip_number", _entry__skip_number, _size__skip_number, _stack__skip_number, _pcsp__skip_number},
+    {"_skip_object", _entry__skip_object, _size__skip_object, _stack__skip_object, _pcsp__skip_object},
+    {"_skip_one", _entry__skip_one, _size__skip_one, _stack__skip_one, _pcsp__skip_one},
+    {"_unquote", _entry__unquote, _size__unquote, _stack__unquote, _pcsp__unquote},
+    {"_validate_one", _entry__validate_one, _size__validate_one, _stack__validate_one, _pcsp__validate_one},
+    {"_validate_utf8", _entry__validate_utf8, _size__validate_utf8, _stack__validate_utf8, _pcsp__validate_utf8},
+    {"_validate_utf8_fast", _entry__validate_utf8_fast, _size__validate_utf8_fast, _stack__validate_utf8_fast, _pcsp__validate_utf8_fast},
+    {"_value", _entry__value, _size__value, _stack__value, _pcsp__value},
+    {"_vnumber", _entry__vnumber, _size__vnumber, _stack__vnumber, _pcsp__vnumber},
+    {"_atof_eisel_lemire64", _entry__atof_eisel_lemire64, _size__atof_eisel_lemire64, _stack__atof_eisel_lemire64, _pcsp__atof_eisel_lemire64},
+    {"_atof_native", _entry__atof_native, _size__atof_native, _stack__atof_native, _pcsp__atof_native},
+    {"_decimal_to_f64", _entry__decimal_to_f64, _size__decimal_to_f64, _stack__decimal_to_f64, _pcsp__decimal_to_f64},
+    {"_right_shift", _entry__right_shift, _size__right_shift, _stack__right_shift, _pcsp__right_shift},
+    {"_left_shift", _entry__left_shift, _size__left_shift, _stack__left_shift, _pcsp__left_shift},
+    {"_vsigned", _entry__vsigned, _size__vsigned, _stack__vsigned, _pcsp__vsigned},
+    {"_vstring", _entry__vstring, _size__vstring, _stack__vstring, _pcsp__vstring},
+    {"_vunsigned", _entry__vunsigned, _size__vunsigned, _stack__vunsigned, _pcsp__vunsigned},
+}

vendor/github.com/bytedance/sonic/internal/native/avx2/native_amd64.go

@@ -1,5 +1,7 @@
 // Code generated by Makefile, DO NOT EDIT.
 
+// Code generated by Makefile, DO NOT EDIT.
+
 /*
  * Copyright 2021 ByteDance Inc.
  *
@@ -22,114 +24,168 @@ import (
     `unsafe`
 
     `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+var (
+    __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)
+
+    __lspace func(sp unsafe.Pointer, nb int, off int) (ret int)
+
+    __quote func(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn unsafe.Pointer, flags uint64) (ret int)
+
+    __html_escape func(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn unsafe.Pointer) (ret int)
+
+    __unquote func(sp unsafe.Pointer, nb int, dp unsafe.Pointer, ep unsafe.Pointer, flags uint64) (ret int)
+
+    __value func(s unsafe.Pointer, n int, p int, v unsafe.Pointer, flags uint64) (ret int)
+
+    __vstring func(s unsafe.Pointer, p unsafe.Pointer, v unsafe.Pointer, flags uint64)
+
+    __vnumber func(s unsafe.Pointer, p unsafe.Pointer, v unsafe.Pointer)
+
+    __vsigned func(s unsafe.Pointer, p unsafe.Pointer, v unsafe.Pointer)
+
+    __vunsigned func(s unsafe.Pointer, p unsafe.Pointer, v unsafe.Pointer)
+
+    __skip_one func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer, flags uint64) (ret int)
+
+    __skip_one_fast func(s unsafe.Pointer, p unsafe.Pointer) (ret int)
+
+    __skip_array func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer, flags uint64) (ret int)
+
+    __skip_object func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer, flags uint64) (ret int)
+
+    __skip_number func(s unsafe.Pointer, p unsafe.Pointer) (ret int)
+
+    __validate_one func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer) (ret int)
+
+    __get_by_path func(s unsafe.Pointer, p unsafe.Pointer, path unsafe.Pointer, m unsafe.Pointer) (ret int)
+
+    __validate_utf8 func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer) (ret int)
+
+    __validate_utf8_fast func(s unsafe.Pointer)  (ret int)
+
+    __fsm_exec func(m unsafe.Pointer, s unsafe.Pointer, p unsafe.Pointer, flags uint64) (ret int)
 )
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __i64toa(out *byte, val int64) (ret int)
+func i64toa(out *byte, val int64) (ret int) {
+    return __i64toa(rt.NoEscape(unsafe.Pointer(out)), val)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __u64toa(out *byte, val uint64) (ret int)
+func u64toa(out *byte, val uint64) (ret int) {
+    return __u64toa(rt.NoEscape(unsafe.Pointer(out)), val)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __f64toa(out *byte, val float64) (ret int)
+func f64toa(out *byte, val float64) (ret int) {
+    return __f64toa(rt.NoEscape(unsafe.Pointer(out)), val)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __f32toa(out *byte, val float32) (ret int)
+func f32toa(out *byte, val float32) (ret int) {
+    return __f32toa(rt.NoEscape(unsafe.Pointer(out)), val)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __lspace(sp unsafe.Pointer, nb int, off int) (ret int)
+func lspace(sp unsafe.Pointer, nb int, off int) (ret int) {
+    return __lspace(rt.NoEscape(sp), nb, off)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __quote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int, flags uint64) (ret int)
+func quote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int, flags uint64) (ret int) {
+    return __quote(rt.NoEscape(unsafe.Pointer(sp)), nb, rt.NoEscape(unsafe.Pointer(dp)), rt.NoEscape(unsafe.Pointer(dn)), flags)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __html_escape(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int) (ret int)
+func html_escape(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int) (ret int) {
+    return __html_escape(rt.NoEscape(unsafe.Pointer(sp)), nb, rt.NoEscape(unsafe.Pointer(dp)), rt.NoEscape(unsafe.Pointer(dn)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __unquote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, ep *int, flags uint64) (ret int)
+func unquote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, ep *int, flags uint64) (ret int) {
+    return __unquote(rt.NoEscape(unsafe.Pointer(sp)), nb, rt.NoEscape(unsafe.Pointer(dp)), rt.NoEscape(unsafe.Pointer(ep)), flags)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __value(s unsafe.Pointer, n int, p int, v *types.JsonState, flags uint64) (ret int)
+func value(s unsafe.Pointer, n int, p int, v *types.JsonState, flags uint64) (ret int) {
+    return __value(rt.NoEscape(unsafe.Pointer(s)), n, p, rt.NoEscape(unsafe.Pointer(v)), flags)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __vstring(s *string, p *int, v *types.JsonState, flags uint64)
+func vstring(s *string, p *int, v *types.JsonState, flags uint64) {
+    __vstring(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(v)), flags)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __vnumber(s *string, p *int, v *types.JsonState)
+func vnumber(s *string, p *int, v *types.JsonState) {
+    __vnumber(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(v)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __vsigned(s *string, p *int, v *types.JsonState)
+func vsigned(s *string, p *int, v *types.JsonState) {
+    __vsigned(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(v)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __vunsigned(s *string, p *int, v *types.JsonState)
+func vunsigned(s *string, p *int, v *types.JsonState) {
+    __vunsigned(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(v)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __skip_one(s *string, p *int, m *types.StateMachine, flags uint64) (ret int)
+func skip_one(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) {
+    return __skip_one(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)), flags)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __skip_one_fast(s *string, p *int) (ret int)
+func skip_one_fast(s *string, p *int) (ret int) {
+    return __skip_one_fast(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __skip_array(s *string, p *int, m *types.StateMachine, flags uint64) (ret int)
+func skip_array(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) {
+    return __skip_array(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)), flags)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __skip_object(s *string, p *int, m *types.StateMachine, flags uint64) (ret int)
+func skip_object(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) {
+    return __skip_object(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)), flags)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __skip_number(s *string, p *int) (ret int)
+func skip_number(s *string, p *int) (ret int) {
+    return __skip_number(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __validate_one(s *string, p *int, m *types.StateMachine) (ret int)
+func validate_one(s *string, p *int, m *types.StateMachine) (ret int) {
+    return __validate_one(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __get_by_path(s *string, p *int, path *[]interface{}, m *types.StateMachine) (ret int)
+func get_by_path(s *string, p *int, path *[]interface{}, m *types.StateMachine) (ret int) {
+    return __get_by_path(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(path)), rt.NoEscape(unsafe.Pointer(m)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __validate_utf8(s *string, p *int, m *types.StateMachine) (ret int)
+func validate_utf8(s *string, p *int, m *types.StateMachine) (ret int) {
+    return __validate_utf8(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __validate_utf8_fast(s *string)  (ret int)
+func validate_utf8_fast(s *string)  (ret int) {
+    return __validate_utf8_fast(rt.NoEscape(unsafe.Pointer(s)))
+}
+
+//go:nosplit
+func fsm_exec(m *types.StateMachine, s *string, p *int, flags uint64) (ret int) {
+    return __fsm_exec(rt.NoEscape(unsafe.Pointer(m)), rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), flags)
+}

vendor/github.com/bytedance/sonic/internal/native/avx2/native_export_amd64.go

@@ -1,49 +0,0 @@
-// Code generated by Makefile, DO NOT EDIT.
-
-/*
- * Copyright 2021 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 avx2
-
-var (
-    S_f64toa = _subr__f64toa
-    S_f32toa = _subr__f32toa
-    S_i64toa = _subr__i64toa
-    S_u64toa = _subr__u64toa
-    S_lspace = _subr__lspace
-)
-
-var (
-    S_quote   = _subr__quote
-    S_unquote = _subr__unquote
-)
-
-var (
-    S_value     = _subr__value
-    S_vstring   = _subr__vstring
-    S_vnumber   = _subr__vnumber
-    S_vsigned   = _subr__vsigned
-    S_vunsigned = _subr__vunsigned
-)
-
-var (
-    S_skip_one    = _subr__skip_one
-    S_skip_one_fast = _subr__skip_one_fast
-    S_skip_array  = _subr__skip_array
-    S_skip_object = _subr__skip_object
-    S_skip_number = _subr__skip_number
-    S_get_by_path = _subr__get_by_path
-)

vendor/github.com/bytedance/sonic/internal/native/avx2/native_subr_amd64.go

@@ -3,107 +3,608 @@
 
 package avx2
 
-//go:nosplit
-//go:noescape
-//goland:noinspection ALL
-func __native_entry__() uintptr
+import (
+	`github.com/bytedance/sonic/loader`
+)
 
-var (
-    _subr__f32toa             = __native_entry__() + 33888
-    _subr__f64toa             = __native_entry__() + 288
-    _subr__get_by_path        = __native_entry__() + 28336
-    _subr__html_escape        = __native_entry__() + 10496
-    _subr__i64toa             = __native_entry__() + 3584
-    _subr__lspace             = __native_entry__() + 64
-    _subr__quote              = __native_entry__() + 5072
-    _subr__skip_array         = __native_entry__() + 20688
-    _subr__skip_number        = __native_entry__() + 24912
-    _subr__skip_object        = __native_entry__() + 22736
-    _subr__skip_one           = __native_entry__() + 25072
-    _subr__skip_one_fast      = __native_entry__() + 25488
-    _subr__u64toa             = __native_entry__() + 3696
-    _subr__unquote            = __native_entry__() + 7888
-    _subr__validate_one       = __native_entry__() + 25136
-    _subr__validate_utf8      = __native_entry__() + 30320
-    _subr__validate_utf8_fast = __native_entry__() + 31280
-    _subr__value              = __native_entry__() + 15024
-    _subr__vnumber            = __native_entry__() + 18352
-    _subr__vsigned            = __native_entry__() + 19968
-    _subr__vstring            = __native_entry__() + 17024
-    _subr__vunsigned          = __native_entry__() + 20336
+const (
+    _entry__f32toa = 34624
+    _entry__f64toa = 320
+    _entry__format_significand = 38736
+    _entry__format_integer = 3168
+    _entry__fsm_exec = 21072
+    _entry__advance_ns = 16928
+    _entry__advance_string = 17664
+    _entry__advance_string_default = 40160
+    _entry__do_skip_number = 23696
+    _entry__get_by_path = 28864
+    _entry__skip_one_fast = 25936
+    _entry__html_escape = 10560
+    _entry__i64toa = 3600
+    _entry__u64toa = 3712
+    _entry__lspace = 64
+    _entry__quote = 5104
+    _entry__skip_array = 21024
+    _entry__skip_number = 25392
+    _entry__skip_object = 23088
+    _entry__skip_one = 25536
+    _entry__unquote = 7888
+    _entry__validate_one = 25584
+    _entry__validate_utf8 = 31040
+    _entry__validate_utf8_fast = 31984
+    _entry__value = 15376
+    _entry__vnumber = 18800
+    _entry__atof_eisel_lemire64 = 12624
+    _entry__atof_native = 14768
+    _entry__decimal_to_f64 = 13056
+    _entry__right_shift = 39696
+    _entry__left_shift = 39200
+    _entry__vsigned = 20352
+    _entry__vstring = 17424
+    _entry__vunsigned = 20672
 )
 
 const (
     _stack__f32toa = 48
     _stack__f64toa = 80
-    _stack__get_by_path = 296
+    _stack__format_significand = 24
+    _stack__format_integer = 16
+    _stack__fsm_exec = 144
+    _stack__advance_ns = 8
+    _stack__advance_string = 56
+    _stack__advance_string_default = 48
+    _stack__do_skip_number = 48
+    _stack__get_by_path = 272
+    _stack__skip_one_fast = 184
     _stack__html_escape = 72
     _stack__i64toa = 16
+    _stack__u64toa = 8
     _stack__lspace = 8
     _stack__quote = 56
-    _stack__skip_array = 128
-    _stack__skip_number = 72
-    _stack__skip_object = 128
-    _stack__skip_one = 128
-    _stack__skip_one_fast = 208
-    _stack__u64toa = 8
+    _stack__skip_array = 152
+    _stack__skip_number = 88
+    _stack__skip_object = 152
+    _stack__skip_one = 152
     _stack__unquote = 72
-    _stack__validate_one = 128
+    _stack__validate_one = 152
     _stack__validate_utf8 = 48
     _stack__validate_utf8_fast = 176
     _stack__value = 328
     _stack__vnumber = 240
+    _stack__atof_eisel_lemire64 = 32
+    _stack__atof_native = 136
+    _stack__decimal_to_f64 = 80
+    _stack__right_shift = 8
+    _stack__left_shift = 24
     _stack__vsigned = 16
     _stack__vstring = 112
-    _stack__vunsigned = 16
-)
-
-var (
-    _ = _subr__f32toa
-    _ = _subr__f64toa
-    _ = _subr__get_by_path
-    _ = _subr__html_escape
-    _ = _subr__i64toa
-    _ = _subr__lspace
-    _ = _subr__quote
-    _ = _subr__skip_array
-    _ = _subr__skip_number
-    _ = _subr__skip_object
-    _ = _subr__skip_one
-    _ = _subr__skip_one_fast
-    _ = _subr__u64toa
-    _ = _subr__unquote
-    _ = _subr__validate_one
-    _ = _subr__validate_utf8
-    _ = _subr__validate_utf8_fast
-    _ = _subr__value
-    _ = _subr__vnumber
-    _ = _subr__vsigned
-    _ = _subr__vstring
-    _ = _subr__vunsigned
+    _stack__vunsigned = 8
 )
 
 const (
-    _ = _stack__f32toa
-    _ = _stack__f64toa
-    _ = _stack__get_by_path
-    _ = _stack__html_escape
-    _ = _stack__i64toa
-    _ = _stack__lspace
-    _ = _stack__quote
-    _ = _stack__skip_array
-    _ = _stack__skip_number
-    _ = _stack__skip_object
-    _ = _stack__skip_one
-    _ = _stack__skip_one_fast
-    _ = _stack__u64toa
-    _ = _stack__unquote
-    _ = _stack__validate_one
-    _ = _stack__validate_utf8
-    _ = _stack__validate_utf8_fast
-    _ = _stack__value
-    _ = _stack__vnumber
-    _ = _stack__vsigned
-    _ = _stack__vstring
-    _ = _stack__vunsigned
+    _size__f32toa = 3392
+    _size__f64toa = 2848
+    _size__format_significand = 464
+    _size__format_integer = 432
+    _size__fsm_exec = 1468
+    _size__advance_ns = 496
+    _size__advance_string = 1088
+    _size__advance_string_default = 768
+    _size__do_skip_number = 1360
+    _size__get_by_path = 2176
+    _size__skip_one_fast = 2428
+    _size__html_escape = 2064
+    _size__i64toa = 48
+    _size__u64toa = 1248
+    _size__lspace = 224
+    _size__quote = 2736
+    _size__skip_array = 48
+    _size__skip_number = 144
+    _size__skip_object = 48
+    _size__skip_one = 48
+    _size__unquote = 2480
+    _size__validate_one = 48
+    _size__validate_utf8 = 672
+    _size__validate_utf8_fast = 2608
+    _size__value = 1004
+    _size__vnumber = 1552
+    _size__atof_eisel_lemire64 = 368
+    _size__atof_native = 608
+    _size__decimal_to_f64 = 1712
+    _size__right_shift = 400
+    _size__left_shift = 496
+    _size__vsigned = 320
+    _size__vstring = 144
+    _size__vunsigned = 336
 )
+
+var (
+    _pcsp__f32toa = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {3350, 48},
+        {3351, 40},
+        {3353, 32},
+        {3355, 24},
+        {3357, 16},
+        {3359, 8},
+        {3363, 0},
+        {3385, 48},
+    }
+    _pcsp__f64toa = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {2788, 56},
+        {2792, 48},
+        {2793, 40},
+        {2795, 32},
+        {2797, 24},
+        {2799, 16},
+        {2801, 8},
+        {2805, 0},
+        {2843, 56},
+    }
+    _pcsp__format_significand = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {452, 24},
+        {453, 16},
+        {455, 8},
+        {457, 0},
+    }
+    _pcsp__format_integer = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {412, 16},
+        {413, 8},
+        {414, 0},
+        {423, 16},
+        {424, 8},
+        {426, 0},
+    }
+    _pcsp__fsm_exec = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {1157, 88},
+        {1161, 48},
+        {1162, 40},
+        {1164, 32},
+        {1166, 24},
+        {1168, 16},
+        {1170, 8},
+        {1171, 0},
+        {1468, 88},
+    }
+    _pcsp__advance_ns = [][2]uint32{
+        {1, 0},
+        {453, 8},
+        {457, 0},
+        {481, 8},
+        {486, 0},
+    }
+    _pcsp__advance_string = [][2]uint32{
+        {14, 0},
+        {18, 8},
+        {20, 16},
+        {22, 24},
+        {24, 32},
+        {26, 40},
+        {27, 48},
+        {433, 56},
+        {437, 48},
+        {438, 40},
+        {440, 32},
+        {442, 24},
+        {444, 16},
+        {446, 8},
+        {450, 0},
+        {1078, 56},
+    }
+    _pcsp__advance_string_default = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {332, 48},
+        {333, 40},
+        {335, 32},
+        {337, 24},
+        {339, 16},
+        {341, 8},
+        {345, 0},
+        {757, 48},
+    }
+    _pcsp__do_skip_number = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {1274, 48},
+        {1275, 40},
+        {1277, 32},
+        {1279, 24},
+        {1281, 16},
+        {1283, 8},
+        {1287, 0},
+        {1360, 48},
+    }
+    _pcsp__get_by_path = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {2049, 88},
+        {2053, 48},
+        {2054, 40},
+        {2056, 32},
+        {2058, 24},
+        {2060, 16},
+        {2062, 8},
+        {2063, 0},
+        {2170, 88},
+    }
+    _pcsp__skip_one_fast = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {418, 176},
+        {419, 168},
+        {421, 160},
+        {423, 152},
+        {425, 144},
+        {427, 136},
+        {431, 128},
+        {2428, 176},
+    }
+    _pcsp__html_escape = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {2045, 72},
+        {2049, 48},
+        {2050, 40},
+        {2052, 32},
+        {2054, 24},
+        {2056, 16},
+        {2058, 8},
+        {2063, 0},
+    }
+    _pcsp__i64toa = [][2]uint32{
+        {14, 0},
+        {34, 8},
+        {36, 0},
+    }
+    _pcsp__u64toa = [][2]uint32{
+        {1, 0},
+        {161, 8},
+        {162, 0},
+        {457, 8},
+        {458, 0},
+        {758, 8},
+        {759, 0},
+        {1225, 8},
+        {1227, 0},
+    }
+    _pcsp__lspace = [][2]uint32{
+        {1, 0},
+        {184, 8},
+        {188, 0},
+        {204, 8},
+        {208, 0},
+        {215, 8},
+        {220, 0},
+    }
+    _pcsp__quote = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {2687, 56},
+        {2691, 48},
+        {2692, 40},
+        {2694, 32},
+        {2696, 24},
+        {2698, 16},
+        {2700, 8},
+        {2704, 0},
+        {2731, 56},
+    }
+    _pcsp__skip_array = [][2]uint32{
+        {1, 0},
+        {28, 8},
+        {34, 0},
+    }
+    _pcsp__skip_number = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {100, 40},
+        {101, 32},
+        {103, 24},
+        {105, 16},
+        {107, 8},
+        {108, 0},
+        {139, 40},
+    }
+    _pcsp__skip_object = [][2]uint32{
+        {1, 0},
+        {28, 8},
+        {34, 0},
+    }
+    _pcsp__skip_one = [][2]uint32{
+        {1, 0},
+        {30, 8},
+        {36, 0},
+    }
+    _pcsp__unquote = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {79, 72},
+        {83, 48},
+        {84, 40},
+        {86, 32},
+        {88, 24},
+        {90, 16},
+        {92, 8},
+        {96, 0},
+        {2464, 72},
+    }
+    _pcsp__validate_one = [][2]uint32{
+        {1, 0},
+        {35, 8},
+        {41, 0},
+    }
+    _pcsp__validate_utf8 = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {11, 40},
+        {623, 48},
+        {627, 40},
+        {628, 32},
+        {630, 24},
+        {632, 16},
+        {634, 8},
+        {635, 0},
+        {666, 48},
+    }
+    _pcsp__validate_utf8_fast = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {5, 16},
+        {1738, 176},
+        {1739, 168},
+        {1743, 160},
+        {2018, 176},
+        {2019, 168},
+        {2023, 160},
+        {2600, 176},
+    }
+    _pcsp__value = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {988, 88},
+        {992, 48},
+        {993, 40},
+        {995, 32},
+        {997, 24},
+        {999, 16},
+        {1001, 8},
+        {1004, 0},
+    }
+    _pcsp__vnumber = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {803, 104},
+        {807, 48},
+        {808, 40},
+        {810, 32},
+        {812, 24},
+        {814, 16},
+        {816, 8},
+        {817, 0},
+        {1547, 104},
+    }
+    _pcsp__atof_eisel_lemire64 = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {292, 32},
+        {293, 24},
+        {295, 16},
+        {297, 8},
+        {298, 0},
+        {362, 32},
+    }
+    _pcsp__atof_native = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {587, 56},
+        {591, 8},
+        {593, 0},
+    }
+    _pcsp__decimal_to_f64 = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {1673, 56},
+        {1677, 48},
+        {1678, 40},
+        {1680, 32},
+        {1682, 24},
+        {1684, 16},
+        {1686, 8},
+        {1690, 0},
+        {1702, 56},
+    }
+    _pcsp__right_shift = [][2]uint32{
+        {1, 0},
+        {318, 8},
+        {319, 0},
+        {387, 8},
+        {388, 0},
+        {396, 8},
+        {398, 0},
+    }
+    _pcsp__left_shift = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {363, 24},
+        {364, 16},
+        {366, 8},
+        {367, 0},
+        {470, 24},
+        {471, 16},
+        {473, 8},
+        {474, 0},
+        {486, 24},
+    }
+    _pcsp__vsigned = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {112, 16},
+        {113, 8},
+        {114, 0},
+        {125, 16},
+        {126, 8},
+        {127, 0},
+        {260, 16},
+        {261, 8},
+        {262, 0},
+        {266, 16},
+        {267, 8},
+        {268, 0},
+        {306, 16},
+        {307, 8},
+        {308, 0},
+        {316, 16},
+        {317, 8},
+        {319, 0},
+    }
+    _pcsp__vstring = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {11, 40},
+        {105, 56},
+        {109, 40},
+        {110, 32},
+        {112, 24},
+        {114, 16},
+        {116, 8},
+        {118, 0},
+    }
+    _pcsp__vunsigned = [][2]uint32{
+        {1, 0},
+        {71, 8},
+        {72, 0},
+        {83, 8},
+        {84, 0},
+        {107, 8},
+        {108, 0},
+        {273, 8},
+        {274, 0},
+        {312, 8},
+        {313, 0},
+        {320, 8},
+        {322, 0},
+    }
+)
+
+var Funcs = []loader.CFunc{
+    {"__native_entry__", 0, 67, 0, nil},
+    {"_f32toa", _entry__f32toa, _size__f32toa, _stack__f32toa, _pcsp__f32toa},
+    {"_f64toa", _entry__f64toa, _size__f64toa, _stack__f64toa, _pcsp__f64toa},
+    {"_format_significand", _entry__format_significand, _size__format_significand, _stack__format_significand, _pcsp__format_significand},
+    {"_format_integer", _entry__format_integer, _size__format_integer, _stack__format_integer, _pcsp__format_integer},
+    {"_fsm_exec", _entry__fsm_exec, _size__fsm_exec, _stack__fsm_exec, _pcsp__fsm_exec},
+    {"_advance_ns", _entry__advance_ns, _size__advance_ns, _stack__advance_ns, _pcsp__advance_ns},
+    {"_advance_string", _entry__advance_string, _size__advance_string, _stack__advance_string, _pcsp__advance_string},
+    {"_advance_string_default", _entry__advance_string_default, _size__advance_string_default, _stack__advance_string_default, _pcsp__advance_string_default},
+    {"_do_skip_number", _entry__do_skip_number, _size__do_skip_number, _stack__do_skip_number, _pcsp__do_skip_number},
+    {"_get_by_path", _entry__get_by_path, _size__get_by_path, _stack__get_by_path, _pcsp__get_by_path},
+    {"_skip_one_fast", _entry__skip_one_fast, _size__skip_one_fast, _stack__skip_one_fast, _pcsp__skip_one_fast},
+    {"_html_escape", _entry__html_escape, _size__html_escape, _stack__html_escape, _pcsp__html_escape},
+    {"_i64toa", _entry__i64toa, _size__i64toa, _stack__i64toa, _pcsp__i64toa},
+    {"_u64toa", _entry__u64toa, _size__u64toa, _stack__u64toa, _pcsp__u64toa},
+    {"_lspace", _entry__lspace, _size__lspace, _stack__lspace, _pcsp__lspace},
+    {"_quote", _entry__quote, _size__quote, _stack__quote, _pcsp__quote},
+    {"_skip_array", _entry__skip_array, _size__skip_array, _stack__skip_array, _pcsp__skip_array},
+    {"_skip_number", _entry__skip_number, _size__skip_number, _stack__skip_number, _pcsp__skip_number},
+    {"_skip_object", _entry__skip_object, _size__skip_object, _stack__skip_object, _pcsp__skip_object},
+    {"_skip_one", _entry__skip_one, _size__skip_one, _stack__skip_one, _pcsp__skip_one},
+    {"_unquote", _entry__unquote, _size__unquote, _stack__unquote, _pcsp__unquote},
+    {"_validate_one", _entry__validate_one, _size__validate_one, _stack__validate_one, _pcsp__validate_one},
+    {"_validate_utf8", _entry__validate_utf8, _size__validate_utf8, _stack__validate_utf8, _pcsp__validate_utf8},
+    {"_validate_utf8_fast", _entry__validate_utf8_fast, _size__validate_utf8_fast, _stack__validate_utf8_fast, _pcsp__validate_utf8_fast},
+    {"_value", _entry__value, _size__value, _stack__value, _pcsp__value},
+    {"_vnumber", _entry__vnumber, _size__vnumber, _stack__vnumber, _pcsp__vnumber},
+    {"_atof_eisel_lemire64", _entry__atof_eisel_lemire64, _size__atof_eisel_lemire64, _stack__atof_eisel_lemire64, _pcsp__atof_eisel_lemire64},
+    {"_atof_native", _entry__atof_native, _size__atof_native, _stack__atof_native, _pcsp__atof_native},
+    {"_decimal_to_f64", _entry__decimal_to_f64, _size__decimal_to_f64, _stack__decimal_to_f64, _pcsp__decimal_to_f64},
+    {"_right_shift", _entry__right_shift, _size__right_shift, _stack__right_shift, _pcsp__right_shift},
+    {"_left_shift", _entry__left_shift, _size__left_shift, _stack__left_shift, _pcsp__left_shift},
+    {"_vsigned", _entry__vsigned, _size__vsigned, _stack__vsigned, _pcsp__vsigned},
+    {"_vstring", _entry__vstring, _size__vstring, _stack__vstring, _pcsp__vstring},
+    {"_vunsigned", _entry__vunsigned, _size__vunsigned, _stack__vunsigned, _pcsp__vunsigned},
+}

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

@@ -24,6 +24,8 @@ 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`
+    `github.com/bytedance/sonic/loader`
 )
 
 const (
@@ -40,8 +42,9 @@ var (
 )
 
 var (
-    S_quote   uintptr
-    S_unquote uintptr
+    S_quote       uintptr
+    S_unquote     uintptr
+    S_html_escape uintptr
 )
 
 var (
@@ -53,140 +56,148 @@ var (
 )
 
 var (
-    S_skip_one    uintptr
-    S_skip_one_fast    uintptr
-    S_get_by_path    uintptr
-    S_skip_array  uintptr
-    S_skip_object uintptr
-    S_skip_number uintptr
+    S_skip_one      uintptr
+    S_skip_one_fast uintptr
+    S_get_by_path   uintptr
+    S_skip_array    uintptr
+    S_skip_object   uintptr
+    S_skip_number   uintptr
+)
+
+var (
+    S_validate_one       uintptr
+    S_validate_utf8      uintptr
+    S_validate_utf8_fast 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) 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)
+
+    __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
+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:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func Unquote(s unsafe.Pointer, nb int, dp unsafe.Pointer, ep *int, flags uint64) int
+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:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func HTMLEscape(s unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int) int
+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:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func Value(s unsafe.Pointer, n int, p int, v *types.JsonState, flags uint64) int
+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:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func SkipOne(s *string, p *int, m *types.StateMachine, flags uint64) int
+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:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func SkipOneFast(s *string, p *int) int
+func SkipOneFast(s *string, p *int) int {
+    return __SkipOneFast(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func GetByPath(s *string, p *int, path *[]interface{}, m *types.StateMachine) int
+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:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func ValidateOne(s *string, p *int, m *types.StateMachine) int
+func ValidateOne(s *string, p *int, m *types.StateMachine) int {
+    return __ValidateOne(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func I64toa(out *byte, val int64) (ret int)
+func I64toa(out *byte, val int64) (ret int) {
+    return __I64toa(rt.NoEscape(unsafe.Pointer(out)), val)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func U64toa(out *byte, val uint64) (ret int)
+func U64toa(out *byte, val uint64) (ret int) {
+    return __U64toa(rt.NoEscape(unsafe.Pointer(out)), val)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func F64toa(out *byte, val float64) (ret int)
+func F64toa(out *byte, val float64) (ret int) {
+    return __F64toa(rt.NoEscape(unsafe.Pointer(out)), val)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func ValidateUTF8(s *string, p *int, m *types.StateMachine) (ret int)
+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
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func ValidateUTF8Fast(s *string) (ret int)
+func ValidateUTF8Fast(s *string) (ret int) {
+    return __ValidateUTF8Fast(rt.NoEscape(unsafe.Pointer(s)))
+}
+
+var stubs = []loader.GoC{
+    {"_f64toa", &S_f64toa, &__F64toa},
+    {"_f32toa", &S_f32toa, nil},
+    {"_i64toa", &S_i64toa, &__I64toa},
+    {"_u64toa", &S_u64toa, &__U64toa},
+    {"_lspace", &S_lspace, nil},
+    {"_quote", &S_quote, &__Quote},
+    {"_unquote", &S_unquote, &__Unquote},
+    {"_html_escape", &S_html_escape, &__HTMLEscape},
+    {"_value", &S_value, &__Value},
+    {"_vstring", &S_vstring, nil},
+    {"_vnumber", &S_vnumber, nil},
+    {"_vsigned", &S_vsigned, nil},
+    {"_vunsigned", &S_vunsigned, nil},
+    {"_skip_one", &S_skip_one, &__SkipOne},
+    {"_skip_one_fast", &S_skip_one_fast, &__SkipOneFast},
+    {"_get_by_path", &S_get_by_path, &__GetByPath},
+    {"_skip_array", &S_skip_array, nil},
+    {"_skip_object", &S_skip_object, nil},
+    {"_skip_number", &S_skip_number, nil},
+    {"_validate_one", &S_validate_one, &__ValidateOne},
+    {"_validate_utf8", &S_validate_utf8, &__ValidateUTF8},
+    {"_validate_utf8_fast", &S_validate_utf8_fast, &__ValidateUTF8Fast},
+}
 
 func useAVX() {
-    S_f64toa      = avx.S_f64toa
-    S_f32toa      = avx.S_f32toa
-    S_i64toa      = avx.S_i64toa
-    S_u64toa      = avx.S_u64toa
-    S_lspace      = avx.S_lspace
-    S_quote       = avx.S_quote
-    S_unquote     = avx.S_unquote
-    S_value       = avx.S_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
-    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
+    loader.WrapGoC(avx.Text__native_entry__, avx.Funcs, stubs, "avx", "avx/native.c")
 }
 
 func useAVX2() {
-    S_f64toa      = avx2.S_f64toa
-    S_f32toa      = avx2.S_f32toa
-    S_i64toa      = avx2.S_i64toa
-    S_u64toa      = avx2.S_u64toa
-    S_lspace      = avx2.S_lspace
-    S_quote       = avx2.S_quote
-    S_unquote     = avx2.S_unquote
-    S_value       = avx2.S_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
-    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
+    loader.WrapGoC(avx2.Text__native_entry__, avx2.Funcs, stubs, "avx2", "avx2/native.c")
 }
 
 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
+    loader.WrapGoC(sse.Text__native_entry__, sse.Funcs, stubs, "sse", "sse/native.c")
 }
 
 func init() {

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

@@ -1,137 +0,0 @@
-//
-// Copyright 2021 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.
-//
-
-#include "go_asm.h"
-#include "funcdata.h"
-#include "textflag.h"
-
-TEXT ·Quote(SB), NOSPLIT, $0 - 48
-    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0
-    JE   2(PC)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx2·__quote(SB)
-    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0
-    JE   2(PC)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx·__quote(SB)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕sse·__quote(SB)
-
-TEXT ·Unquote(SB), NOSPLIT, $0 - 48
-    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0
-    JE   2(PC)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx2·__unquote(SB)
-    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0
-    JE   2(PC)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx·__unquote(SB)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕sse·__unquote(SB)
-
-TEXT ·HTMLEscape(SB), NOSPLIT, $0 - 40
-    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0
-    JE   2(PC)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx2·__html_escape(SB)
-    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0
-    JE   2(PC)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx·__html_escape(SB)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕sse·__html_escape(SB)
-
-TEXT ·Value(SB), NOSPLIT, $0 - 48
-    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0
-    JE   2(PC)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx2·__value(SB)
-    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0
-    JE   2(PC)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx·__value(SB)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕sse·__value(SB)
-
-TEXT ·SkipOne(SB), NOSPLIT, $0 - 40
-    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0
-    JE   2(PC)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx2·__skip_one(SB)
-    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0
-    JE   2(PC)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx·__skip_one(SB)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕sse·__skip_one(SB)
-
-TEXT ·SkipOneFast(SB), NOSPLIT, $0 - 24
-    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0
-    JE   2(PC)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx2·__skip_one_fast(SB)
-    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0
-    JE   2(PC)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx·__skip_one_fast(SB)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕sse·__skip_one_fast(SB)
-
-TEXT ·GetByPath(SB), NOSPLIT, $0 - 40
-    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0
-    JE   2(PC)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx2·__get_by_path(SB)
-    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0
-    JE   2(PC)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx·__get_by_path(SB)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕sse·__get_by_path(SB)
-
-TEXT ·ValidateOne(SB), NOSPLIT, $0 - 32
-    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0
-    JE   2(PC)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx2·__validate_one(SB)
-    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0
-    JE   2(PC)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx·__validate_one(SB)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕sse·__validate_one(SB)
-
-TEXT ·ValidateUTF8(SB), NOSPLIT, $0 - 40
-    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0
-    JE   2(PC)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx2·__validate_utf8(SB)
-    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0
-    JE   2(PC)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx·__validate_utf8(SB)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕sse·__validate_utf8(SB)
-
-TEXT ·ValidateUTF8Fast(SB), NOSPLIT, $0 - 16
-    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0
-    JE   2(PC)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx2·__validate_utf8_fast(SB)
-    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0
-    JE   2(PC)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx·__validate_utf8_fast(SB)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕sse·__validate_utf8_fast(SB)
-    
-TEXT ·I64toa(SB), NOSPLIT, $0 - 32
-    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0
-    JE   2(PC)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx2·__i64toa(SB)
-    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0
-    JE   2(PC)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx·__i64toa(SB)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕sse·__i64toa(SB)
-
-TEXT ·U64toa(SB), NOSPLIT, $0 - 32
-    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0
-    JE   2(PC)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx2·__u64toa(SB)
-    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0
-    JE   2(PC)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx·__u64toa(SB)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕sse·__u64toa(SB)
-
-TEXT ·F64toa(SB), NOSPLIT, $0 - 32
-    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0
-    JE   2(PC)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx2·__f64toa(SB)
-    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0
-    JE   2(PC)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx·__f64toa(SB)
-    JMP  github·com∕bytedance∕sonic∕internal∕native∕sse·__f64toa(SB)
-

vendor/github.com/bytedance/sonic/internal/native/fastfloat_amd64_test.tmpl

@@ -1,3 +1,5 @@
+// Code generated by Makefile, DO NOT EDIT.
+
 /*
  * Copyright 2021 ByteDance Inc.
  *
@@ -17,35 +19,35 @@
 package {{PACKAGE}}
 
 import (
+    `encoding/json`
     `math`
+    `math/rand`
     `strconv`
     `testing`
-    `math/rand`
-    `encoding/json`
 
     `github.com/stretchr/testify/assert`
 )
 
 func TestFastFloat_Encode(t *testing.T) {
     var buf [64]byte
-    assert.Equal(t, "0"                         , string(buf[:__f64toa(&buf[0], 0)]))
-    assert.Equal(t, "-0"                         , string(buf[:__f64toa(&buf[0], math.Float64frombits(0x8000000000000000))]))
-    assert.Equal(t, "12340000000"               , string(buf[:__f64toa(&buf[0], 1234e7)]))
-    assert.Equal(t, "12.34"                     , string(buf[:__f64toa(&buf[0], 1234e-2)]))
-    assert.Equal(t, "0.001234"                  , string(buf[:__f64toa(&buf[0], 1234e-6)]))
-    assert.Equal(t, "1e+30"                      , string(buf[:__f64toa(&buf[0], 1e30)]))
-    assert.Equal(t, "1.234e+33"                  , string(buf[:__f64toa(&buf[0], 1234e30)]))
-    assert.Equal(t, "1.234e+308"                 , string(buf[:__f64toa(&buf[0], 1234e305)]))
-    assert.Equal(t, "1.234e-317"                , string(buf[:__f64toa(&buf[0], 1234e-320)]))
-    assert.Equal(t, "1.7976931348623157e+308"    , string(buf[:__f64toa(&buf[0], 1.7976931348623157e308)]))
-    assert.Equal(t, "-12340000000"              , string(buf[:__f64toa(&buf[0], -1234e7)]))
-    assert.Equal(t, "-12.34"                    , string(buf[:__f64toa(&buf[0], -1234e-2)]))
-    assert.Equal(t, "-0.001234"                 , string(buf[:__f64toa(&buf[0], -1234e-6)]))
-    assert.Equal(t, "-1e+30"                     , string(buf[:__f64toa(&buf[0], -1e30)]))
-    assert.Equal(t, "-1.234e+33"                 , string(buf[:__f64toa(&buf[0], -1234e30)]))
-    assert.Equal(t, "-1.234e+308"                , string(buf[:__f64toa(&buf[0], -1234e305)]))
-    assert.Equal(t, "-1.234e-317"               , string(buf[:__f64toa(&buf[0], -1234e-320)]))
-    assert.Equal(t, "-2.2250738585072014e-308"  , string(buf[:__f64toa(&buf[0], -2.2250738585072014e-308)]))
+    assert.Equal(t, "0"                         , string(buf[:f64toa(&buf[0], 0)]))
+    assert.Equal(t, "-0"                         , string(buf[:f64toa(&buf[0], math.Float64frombits(0x8000000000000000))]))
+    assert.Equal(t, "12340000000"               , string(buf[:f64toa(&buf[0], 1234e7)]))
+    assert.Equal(t, "12.34"                     , string(buf[:f64toa(&buf[0], 1234e-2)]))
+    assert.Equal(t, "0.001234"                  , string(buf[:f64toa(&buf[0], 1234e-6)]))
+    assert.Equal(t, "1e+30"                      , string(buf[:f64toa(&buf[0], 1e30)]))
+    assert.Equal(t, "1.234e+33"                  , string(buf[:f64toa(&buf[0], 1234e30)]))
+    assert.Equal(t, "1.234e+308"                 , string(buf[:f64toa(&buf[0], 1234e305)]))
+    assert.Equal(t, "1.234e-317"                , string(buf[:f64toa(&buf[0], 1234e-320)]))
+    assert.Equal(t, "1.7976931348623157e+308"    , string(buf[:f64toa(&buf[0], 1.7976931348623157e308)]))
+    assert.Equal(t, "-12340000000"              , string(buf[:f64toa(&buf[0], -1234e7)]))
+    assert.Equal(t, "-12.34"                    , string(buf[:f64toa(&buf[0], -1234e-2)]))
+    assert.Equal(t, "-0.001234"                 , string(buf[:f64toa(&buf[0], -1234e-6)]))
+    assert.Equal(t, "-1e+30"                     , string(buf[:f64toa(&buf[0], -1e30)]))
+    assert.Equal(t, "-1.234e+33"                 , string(buf[:f64toa(&buf[0], -1234e30)]))
+    assert.Equal(t, "-1.234e+308"                , string(buf[:f64toa(&buf[0], -1234e305)]))
+    assert.Equal(t, "-1.234e-317"               , string(buf[:f64toa(&buf[0], -1234e-320)]))
+    assert.Equal(t, "-2.2250738585072014e-308"  , string(buf[:f64toa(&buf[0], -2.2250738585072014e-308)]))
 }
 
 func TestFastFloat_Random(t *testing.T) {
@@ -56,7 +58,7 @@ func TestFastFloat_Random(t *testing.T) {
         f64 := math.Float64frombits(b64)
 
         jout, jerr := json.Marshal(f64)
-        n := __f64toa(&buf[0], f64)
+        n := f64toa(&buf[0], f64)
         if jerr == nil {
             assert.Equal(t, jout, buf[:n])
         } else {
@@ -65,7 +67,7 @@ func TestFastFloat_Random(t *testing.T) {
 
         f32 := math.Float32frombits(rand.Uint32())
         jout, jerr = json.Marshal(f32)
-        n = __f32toa(&buf[0], f32)
+        n = f32toa(&buf[0], f32)
         if jerr == nil {
             assert.Equal(t, jout, buf[:n])
         } else {
@@ -97,7 +99,7 @@ func BenchmarkParseFloat64(b *testing.B) {
             test: func(b *testing.B) { var buf [64]byte; for i := 0; i < b.N; i++ { strconv.AppendFloat(buf[:0], c.float, 'g', -1, 64) }},
         }, {
             name: "FastFloat",
-            test: func(b *testing.B) { var buf [64]byte; for i := 0; i < b.N; i++ { __f64toa(&buf[0], c.float) }},
+            test: func(b *testing.B) { var buf [64]byte; for i := 0; i < b.N; i++ { f64toa(&buf[0], c.float) }},
         }}
         for _, bm := range f64bench {
             name := bm.name + "_" + c.name
@@ -128,7 +130,7 @@ func BenchmarkParseFloat32(b *testing.B) {
             test: func(b *testing.B) { var buf [64]byte; for i := 0; i < b.N; i++ { strconv.AppendFloat(buf[:0], float64(c.float), 'g', -1, 32) }},
         }, {
             name: "FastFloat32",
-            test: func(b *testing.B) { var buf [64]byte; for i := 0; i < b.N; i++ { __f32toa(&buf[0], c.float) }},
+            test: func(b *testing.B) { var buf [64]byte; for i := 0; i < b.N; i++ { f32toa(&buf[0], c.float) }},
         }}
         for _, bm := range bench {
             name := bm.name + "_" + c.name

vendor/github.com/bytedance/sonic/internal/native/fastint_amd64_test.tmpl

@@ -1,3 +1,5 @@
+// Code generated by Makefile, DO NOT EDIT.
+
 /*
  * Copyright 2021 ByteDance Inc.
  *
@@ -26,126 +28,126 @@ import (
 
 func TestFastInt_IntToString(t *testing.T) {
     var buf [32]byte
-    assert.Equal(t, "0"                    , string(buf[:__i64toa(&buf[0], 0)]))
-    assert.Equal(t, "1"                    , string(buf[:__i64toa(&buf[0], 1)]))
-    assert.Equal(t, "12"                   , string(buf[:__i64toa(&buf[0], 12)]))
-    assert.Equal(t, "123"                  , string(buf[:__i64toa(&buf[0], 123)]))
-    assert.Equal(t, "1234"                 , string(buf[:__i64toa(&buf[0], 1234)]))
-    assert.Equal(t, "12345"                , string(buf[:__i64toa(&buf[0], 12345)]))
-    assert.Equal(t, "123456"               , string(buf[:__i64toa(&buf[0], 123456)]))
-    assert.Equal(t, "1234567"              , string(buf[:__i64toa(&buf[0], 1234567)]))
-    assert.Equal(t, "12345678"             , string(buf[:__i64toa(&buf[0], 12345678)]))
-    assert.Equal(t, "123456789"            , string(buf[:__i64toa(&buf[0], 123456789)]))
-    assert.Equal(t, "1234567890"           , string(buf[:__i64toa(&buf[0], 1234567890)]))
-    assert.Equal(t, "12345678901"          , string(buf[:__i64toa(&buf[0], 12345678901)]))
-    assert.Equal(t, "123456789012"         , string(buf[:__i64toa(&buf[0], 123456789012)]))
-    assert.Equal(t, "1234567890123"        , string(buf[:__i64toa(&buf[0], 1234567890123)]))
-    assert.Equal(t, "12345678901234"       , string(buf[:__i64toa(&buf[0], 12345678901234)]))
-    assert.Equal(t, "123456789012345"      , string(buf[:__i64toa(&buf[0], 123456789012345)]))
-    assert.Equal(t, "1234567890123456"     , string(buf[:__i64toa(&buf[0], 1234567890123456)]))
-    assert.Equal(t, "12345678901234567"    , string(buf[:__i64toa(&buf[0], 12345678901234567)]))
-    assert.Equal(t, "123456789012345678"   , string(buf[:__i64toa(&buf[0], 123456789012345678)]))
-    assert.Equal(t, "1234567890123456789"  , string(buf[:__i64toa(&buf[0], 1234567890123456789)]))
-    assert.Equal(t, "9223372036854775807"  , string(buf[:__i64toa(&buf[0], 9223372036854775807)]))
-    assert.Equal(t, "-1"                   , string(buf[:__i64toa(&buf[0], -1)]))
-    assert.Equal(t, "-12"                  , string(buf[:__i64toa(&buf[0], -12)]))
-    assert.Equal(t, "-123"                 , string(buf[:__i64toa(&buf[0], -123)]))
-    assert.Equal(t, "-1234"                , string(buf[:__i64toa(&buf[0], -1234)]))
-    assert.Equal(t, "-12345"               , string(buf[:__i64toa(&buf[0], -12345)]))
-    assert.Equal(t, "-123456"              , string(buf[:__i64toa(&buf[0], -123456)]))
-    assert.Equal(t, "-1234567"             , string(buf[:__i64toa(&buf[0], -1234567)]))
-    assert.Equal(t, "-12345678"            , string(buf[:__i64toa(&buf[0], -12345678)]))
-    assert.Equal(t, "-123456789"           , string(buf[:__i64toa(&buf[0], -123456789)]))
-    assert.Equal(t, "-1234567890"          , string(buf[:__i64toa(&buf[0], -1234567890)]))
-    assert.Equal(t, "-12345678901"         , string(buf[:__i64toa(&buf[0], -12345678901)]))
-    assert.Equal(t, "-123456789012"        , string(buf[:__i64toa(&buf[0], -123456789012)]))
-    assert.Equal(t, "-1234567890123"       , string(buf[:__i64toa(&buf[0], -1234567890123)]))
-    assert.Equal(t, "-12345678901234"      , string(buf[:__i64toa(&buf[0], -12345678901234)]))
-    assert.Equal(t, "-123456789012345"     , string(buf[:__i64toa(&buf[0], -123456789012345)]))
-    assert.Equal(t, "-1234567890123456"    , string(buf[:__i64toa(&buf[0], -1234567890123456)]))
-    assert.Equal(t, "-12345678901234567"   , string(buf[:__i64toa(&buf[0], -12345678901234567)]))
-    assert.Equal(t, "-123456789012345678"  , string(buf[:__i64toa(&buf[0], -123456789012345678)]))
-    assert.Equal(t, "-1234567890123456789" , string(buf[:__i64toa(&buf[0], -1234567890123456789)]))
-    assert.Equal(t, "-9223372036854775808" , string(buf[:__i64toa(&buf[0], -9223372036854775808)]))
+    assert.Equal(t, "0"                    , string(buf[:i64toa(&buf[0], 0)]))
+    assert.Equal(t, "1"                    , string(buf[:i64toa(&buf[0], 1)]))
+    assert.Equal(t, "12"                   , string(buf[:i64toa(&buf[0], 12)]))
+    assert.Equal(t, "123"                  , string(buf[:i64toa(&buf[0], 123)]))
+    assert.Equal(t, "1234"                 , string(buf[:i64toa(&buf[0], 1234)]))
+    assert.Equal(t, "12345"                , string(buf[:i64toa(&buf[0], 12345)]))
+    assert.Equal(t, "123456"               , string(buf[:i64toa(&buf[0], 123456)]))
+    assert.Equal(t, "1234567"              , string(buf[:i64toa(&buf[0], 1234567)]))
+    assert.Equal(t, "12345678"             , string(buf[:i64toa(&buf[0], 12345678)]))
+    assert.Equal(t, "123456789"            , string(buf[:i64toa(&buf[0], 123456789)]))
+    assert.Equal(t, "1234567890"           , string(buf[:i64toa(&buf[0], 1234567890)]))
+    assert.Equal(t, "12345678901"          , string(buf[:i64toa(&buf[0], 12345678901)]))
+    assert.Equal(t, "123456789012"         , string(buf[:i64toa(&buf[0], 123456789012)]))
+    assert.Equal(t, "1234567890123"        , string(buf[:i64toa(&buf[0], 1234567890123)]))
+    assert.Equal(t, "12345678901234"       , string(buf[:i64toa(&buf[0], 12345678901234)]))
+    assert.Equal(t, "123456789012345"      , string(buf[:i64toa(&buf[0], 123456789012345)]))
+    assert.Equal(t, "1234567890123456"     , string(buf[:i64toa(&buf[0], 1234567890123456)]))
+    assert.Equal(t, "12345678901234567"    , string(buf[:i64toa(&buf[0], 12345678901234567)]))
+    assert.Equal(t, "123456789012345678"   , string(buf[:i64toa(&buf[0], 123456789012345678)]))
+    assert.Equal(t, "1234567890123456789"  , string(buf[:i64toa(&buf[0], 1234567890123456789)]))
+    assert.Equal(t, "9223372036854775807"  , string(buf[:i64toa(&buf[0], 9223372036854775807)]))
+    assert.Equal(t, "-1"                   , string(buf[:i64toa(&buf[0], -1)]))
+    assert.Equal(t, "-12"                  , string(buf[:i64toa(&buf[0], -12)]))
+    assert.Equal(t, "-123"                 , string(buf[:i64toa(&buf[0], -123)]))
+    assert.Equal(t, "-1234"                , string(buf[:i64toa(&buf[0], -1234)]))
+    assert.Equal(t, "-12345"               , string(buf[:i64toa(&buf[0], -12345)]))
+    assert.Equal(t, "-123456"              , string(buf[:i64toa(&buf[0], -123456)]))
+    assert.Equal(t, "-1234567"             , string(buf[:i64toa(&buf[0], -1234567)]))
+    assert.Equal(t, "-12345678"            , string(buf[:i64toa(&buf[0], -12345678)]))
+    assert.Equal(t, "-123456789"           , string(buf[:i64toa(&buf[0], -123456789)]))
+    assert.Equal(t, "-1234567890"          , string(buf[:i64toa(&buf[0], -1234567890)]))
+    assert.Equal(t, "-12345678901"         , string(buf[:i64toa(&buf[0], -12345678901)]))
+    assert.Equal(t, "-123456789012"        , string(buf[:i64toa(&buf[0], -123456789012)]))
+    assert.Equal(t, "-1234567890123"       , string(buf[:i64toa(&buf[0], -1234567890123)]))
+    assert.Equal(t, "-12345678901234"      , string(buf[:i64toa(&buf[0], -12345678901234)]))
+    assert.Equal(t, "-123456789012345"     , string(buf[:i64toa(&buf[0], -123456789012345)]))
+    assert.Equal(t, "-1234567890123456"    , string(buf[:i64toa(&buf[0], -1234567890123456)]))
+    assert.Equal(t, "-12345678901234567"   , string(buf[:i64toa(&buf[0], -12345678901234567)]))
+    assert.Equal(t, "-123456789012345678"  , string(buf[:i64toa(&buf[0], -123456789012345678)]))
+    assert.Equal(t, "-1234567890123456789" , string(buf[:i64toa(&buf[0], -1234567890123456789)]))
+    assert.Equal(t, "-9223372036854775808" , string(buf[:i64toa(&buf[0], -9223372036854775808)]))
 }
 
 func TestFastInt_UintToString(t *testing.T) {
     var buf [32]byte
-    assert.Equal(t, "0"                    , string(buf[:__u64toa(&buf[0], 0)]))
-    assert.Equal(t, "1"                    , string(buf[:__u64toa(&buf[0], 1)]))
-    assert.Equal(t, "12"                   , string(buf[:__u64toa(&buf[0], 12)]))
-    assert.Equal(t, "123"                  , string(buf[:__u64toa(&buf[0], 123)]))
-    assert.Equal(t, "1234"                 , string(buf[:__u64toa(&buf[0], 1234)]))
-    assert.Equal(t, "12345"                , string(buf[:__u64toa(&buf[0], 12345)]))
-    assert.Equal(t, "123456"               , string(buf[:__u64toa(&buf[0], 123456)]))
-    assert.Equal(t, "1234567"              , string(buf[:__u64toa(&buf[0], 1234567)]))
-    assert.Equal(t, "12345678"             , string(buf[:__u64toa(&buf[0], 12345678)]))
-    assert.Equal(t, "123456789"            , string(buf[:__u64toa(&buf[0], 123456789)]))
-    assert.Equal(t, "1234567890"           , string(buf[:__u64toa(&buf[0], 1234567890)]))
-    assert.Equal(t, "12345678901"          , string(buf[:__u64toa(&buf[0], 12345678901)]))
-    assert.Equal(t, "123456789012"         , string(buf[:__u64toa(&buf[0], 123456789012)]))
-    assert.Equal(t, "1234567890123"        , string(buf[:__u64toa(&buf[0], 1234567890123)]))
-    assert.Equal(t, "12345678901234"       , string(buf[:__u64toa(&buf[0], 12345678901234)]))
-    assert.Equal(t, "123456789012345"      , string(buf[:__u64toa(&buf[0], 123456789012345)]))
-    assert.Equal(t, "1234567890123456"     , string(buf[:__u64toa(&buf[0], 1234567890123456)]))
-    assert.Equal(t, "12345678901234567"    , string(buf[:__u64toa(&buf[0], 12345678901234567)]))
-    assert.Equal(t, "123456789012345678"   , string(buf[:__u64toa(&buf[0], 123456789012345678)]))
-    assert.Equal(t, "1234567890123456789"  , string(buf[:__u64toa(&buf[0], 1234567890123456789)]))
-    assert.Equal(t, "12345678901234567890" , string(buf[:__u64toa(&buf[0], 12345678901234567890)]))
-    assert.Equal(t, "18446744073709551615" , string(buf[:__u64toa(&buf[0], 18446744073709551615)]))
+    assert.Equal(t, "0"                    , string(buf[:u64toa(&buf[0], 0)]))
+    assert.Equal(t, "1"                    , string(buf[:u64toa(&buf[0], 1)]))
+    assert.Equal(t, "12"                   , string(buf[:u64toa(&buf[0], 12)]))
+    assert.Equal(t, "123"                  , string(buf[:u64toa(&buf[0], 123)]))
+    assert.Equal(t, "1234"                 , string(buf[:u64toa(&buf[0], 1234)]))
+    assert.Equal(t, "12345"                , string(buf[:u64toa(&buf[0], 12345)]))
+    assert.Equal(t, "123456"               , string(buf[:u64toa(&buf[0], 123456)]))
+    assert.Equal(t, "1234567"              , string(buf[:u64toa(&buf[0], 1234567)]))
+    assert.Equal(t, "12345678"             , string(buf[:u64toa(&buf[0], 12345678)]))
+    assert.Equal(t, "123456789"            , string(buf[:u64toa(&buf[0], 123456789)]))
+    assert.Equal(t, "1234567890"           , string(buf[:u64toa(&buf[0], 1234567890)]))
+    assert.Equal(t, "12345678901"          , string(buf[:u64toa(&buf[0], 12345678901)]))
+    assert.Equal(t, "123456789012"         , string(buf[:u64toa(&buf[0], 123456789012)]))
+    assert.Equal(t, "1234567890123"        , string(buf[:u64toa(&buf[0], 1234567890123)]))
+    assert.Equal(t, "12345678901234"       , string(buf[:u64toa(&buf[0], 12345678901234)]))
+    assert.Equal(t, "123456789012345"      , string(buf[:u64toa(&buf[0], 123456789012345)]))
+    assert.Equal(t, "1234567890123456"     , string(buf[:u64toa(&buf[0], 1234567890123456)]))
+    assert.Equal(t, "12345678901234567"    , string(buf[:u64toa(&buf[0], 12345678901234567)]))
+    assert.Equal(t, "123456789012345678"   , string(buf[:u64toa(&buf[0], 123456789012345678)]))
+    assert.Equal(t, "1234567890123456789"  , string(buf[:u64toa(&buf[0], 1234567890123456789)]))
+    assert.Equal(t, "12345678901234567890" , string(buf[:u64toa(&buf[0], 12345678901234567890)]))
+    assert.Equal(t, "18446744073709551615" , string(buf[:u64toa(&buf[0], 18446744073709551615)]))
 }
 
- func BenchmarkFastInt_IntToString(b *testing.B) {
-     benchmarks := []struct {
-         name string
-         test func(*testing.B)
-     }{{
-         name: "StdLib-Positive",
-         test: func(b *testing.B) { var buf [32]byte; for i := 0; i < b.N; i++ { strconv.AppendInt(buf[:0], int64(i), 10) }},
-     }, {
-         name: "StdLib-Negative",
-         test: func(b *testing.B) { var buf [32]byte; for i := 0; i < b.N; i++ { strconv.AppendInt(buf[:0], -int64(i), 10) }},
-     }, {
-         name: "FastInt-Positive",
-         test: func(b *testing.B) { var buf [32]byte; for i := 0; i < b.N; i++ { __i64toa(&buf[0], int64(i)) }},
-     }, {
-         name: "FastInt-Negative",
-         test: func(b *testing.B) { var buf [32]byte; for i := 0; i < b.N; i++ { __i64toa(&buf[0], -int64(i)) }},
-     }}
-     for _, bm := range benchmarks {
-         b.Run(bm.name, bm.test)
-     }
- }
+func BenchmarkFastInt_IntToString(b *testing.B) {
+    benchmarks := []struct {
+        name string
+        test func(*testing.B)
+    }{{
+        name: "StdLib-Positive",
+        test: func(b *testing.B) { var buf [32]byte; for i := 0; i < b.N; i++ { strconv.AppendInt(buf[:0], int64(i), 10) }},
+    }, {
+        name: "StdLib-Negative",
+        test: func(b *testing.B) { var buf [32]byte; for i := 0; i < b.N; i++ { strconv.AppendInt(buf[:0], -int64(i), 10) }},
+    }, {
+        name: "FastInt-Positive",
+        test: func(b *testing.B) { var buf [32]byte; for i := 0; i < b.N; i++ { i64toa(&buf[0], int64(i)) }},
+    }, {
+        name: "FastInt-Negative",
+        test: func(b *testing.B) { var buf [32]byte; for i := 0; i < b.N; i++ { i64toa(&buf[0], -int64(i)) }},
+    }}
+    for _, bm := range benchmarks {
+        b.Run(bm.name, bm.test)
+    }
+}
 
- type utoaBench struct {
-     name string
-     num  uint64
- }
+type utoaBench struct {
+    name string
+    num  uint64
+}
 
- func BenchmarkFastInt_UintToString(b *testing.B) {
-     maxUint := "18446744073709551615"
-     benchs := make([]utoaBench, len(maxUint) + 1)
-     benchs[0].name = "Zero"
-     benchs[0].num  = 0
-     for i := 1; i <= len(maxUint); i++ {
-         benchs[i].name = strconv.FormatInt(int64(i), 10) + "-Digs"
-         benchs[i].num, _ = strconv.ParseUint(string(maxUint[:i]), 10, 64)
-     }
+func BenchmarkFastInt_UintToString(b *testing.B) {
+    maxUint := "18446744073709551615"
+    benchs := make([]utoaBench, len(maxUint) + 1)
+    benchs[0].name = "Zero"
+    benchs[0].num  = 0
+    for i := 1; i <= len(maxUint); i++ {
+        benchs[i].name = strconv.FormatInt(int64(i), 10) + "-Digs"
+        benchs[i].num, _ = strconv.ParseUint(string(maxUint[:i]), 10, 64)
+    }
 
-     for _, t := range(benchs) {
-         benchmarks := []struct {
-             name string
-             test func(*testing.B)
-         }{{
-             name: "StdLib",
-             test: func(b *testing.B) { var buf [32]byte; for i := 0; i < b.N; i++ { strconv.AppendUint(buf[:0], t.num, 10) }},
-         }, {
-             name: "FastInt",
-             test: func(b *testing.B) { var buf [32]byte; for i := 0; i < b.N; i++ { __u64toa(&buf[0], t.num) }},
-         }}
-         for _, bm := range benchmarks {
-             name := fmt.Sprintf("%s_%s", bm.name, t.name)
-             b.Run(name, bm.test)
-         }
-     }
- }
+    for _, t := range(benchs) {
+        benchmarks := []struct {
+            name string
+            test func(*testing.B)
+        }{{
+            name: "StdLib",
+            test: func(b *testing.B) { var buf [32]byte; for i := 0; i < b.N; i++ { strconv.AppendUint(buf[:0], t.num, 10) }},
+        }, {
+            name: "FastInt",
+            test: func(b *testing.B) { var buf [32]byte; for i := 0; i < b.N; i++ { u64toa(&buf[0], t.num) }},
+        }}
+        for _, bm := range benchmarks {
+            name := fmt.Sprintf("%s_%s", bm.name, t.name)
+            b.Run(name, bm.test)
+        }
+    }
+}

vendor/github.com/bytedance/sonic/internal/native/native_amd64.tmpl

@@ -1,3 +1,5 @@
+// Code generated by Makefile, DO NOT EDIT.
+
 /*
  * Copyright 2021 ByteDance Inc.
  *
@@ -20,114 +22,168 @@ import (
     `unsafe`
 
     `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+var (
+    __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)
+
+    __lspace func(sp unsafe.Pointer, nb int, off int) (ret int)
+
+    __quote func(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn unsafe.Pointer, flags uint64) (ret int)
+
+    __html_escape func(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn unsafe.Pointer) (ret int)
+
+    __unquote func(sp unsafe.Pointer, nb int, dp unsafe.Pointer, ep unsafe.Pointer, flags uint64) (ret int)
+
+    __value func(s unsafe.Pointer, n int, p int, v unsafe.Pointer, flags uint64) (ret int)
+
+    __vstring func(s unsafe.Pointer, p unsafe.Pointer, v unsafe.Pointer, flags uint64)
+
+    __vnumber func(s unsafe.Pointer, p unsafe.Pointer, v unsafe.Pointer)
+
+    __vsigned func(s unsafe.Pointer, p unsafe.Pointer, v unsafe.Pointer)
+
+    __vunsigned func(s unsafe.Pointer, p unsafe.Pointer, v unsafe.Pointer)
+
+    __skip_one func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer, flags uint64) (ret int)
+
+    __skip_one_fast func(s unsafe.Pointer, p unsafe.Pointer) (ret int)
+
+    __skip_array func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer, flags uint64) (ret int)
+
+    __skip_object func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer, flags uint64) (ret int)
+
+    __skip_number func(s unsafe.Pointer, p unsafe.Pointer) (ret int)
+
+    __validate_one func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer) (ret int)
+
+    __get_by_path func(s unsafe.Pointer, p unsafe.Pointer, path unsafe.Pointer, m unsafe.Pointer) (ret int)
+
+    __validate_utf8 func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer) (ret int)
+
+    __validate_utf8_fast func(s unsafe.Pointer)  (ret int)
+
+    __fsm_exec func(m unsafe.Pointer, s unsafe.Pointer, p unsafe.Pointer, flags uint64) (ret int)
 )
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __i64toa(out *byte, val int64) (ret int)
+func i64toa(out *byte, val int64) (ret int) {
+    return __i64toa(rt.NoEscape(unsafe.Pointer(out)), val)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __u64toa(out *byte, val uint64) (ret int)
+func u64toa(out *byte, val uint64) (ret int) {
+    return __u64toa(rt.NoEscape(unsafe.Pointer(out)), val)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __f64toa(out *byte, val float64) (ret int)
+func f64toa(out *byte, val float64) (ret int) {
+    return __f64toa(rt.NoEscape(unsafe.Pointer(out)), val)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __f32toa(out *byte, val float32) (ret int)
+func f32toa(out *byte, val float32) (ret int) {
+    return __f32toa(rt.NoEscape(unsafe.Pointer(out)), val)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __lspace(sp unsafe.Pointer, nb int, off int) (ret int)
+func lspace(sp unsafe.Pointer, nb int, off int) (ret int) {
+    return __lspace(rt.NoEscape(sp), nb, off)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __quote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int, flags uint64) (ret int)
+func quote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int, flags uint64) (ret int) {
+    return __quote(rt.NoEscape(unsafe.Pointer(sp)), nb, rt.NoEscape(unsafe.Pointer(dp)), rt.NoEscape(unsafe.Pointer(dn)), flags)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __html_escape(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int) (ret int)
+func html_escape(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int) (ret int) {
+    return __html_escape(rt.NoEscape(unsafe.Pointer(sp)), nb, rt.NoEscape(unsafe.Pointer(dp)), rt.NoEscape(unsafe.Pointer(dn)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __unquote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, ep *int, flags uint64) (ret int)
+func unquote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, ep *int, flags uint64) (ret int) {
+    return __unquote(rt.NoEscape(unsafe.Pointer(sp)), nb, rt.NoEscape(unsafe.Pointer(dp)), rt.NoEscape(unsafe.Pointer(ep)), flags)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __value(s unsafe.Pointer, n int, p int, v *types.JsonState, flags uint64) (ret int)
+func value(s unsafe.Pointer, n int, p int, v *types.JsonState, flags uint64) (ret int) {
+    return __value(rt.NoEscape(unsafe.Pointer(s)), n, p, rt.NoEscape(unsafe.Pointer(v)), flags)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __vstring(s *string, p *int, v *types.JsonState, flags uint64)
+func vstring(s *string, p *int, v *types.JsonState, flags uint64) {
+    __vstring(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(v)), flags)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __vnumber(s *string, p *int, v *types.JsonState)
+func vnumber(s *string, p *int, v *types.JsonState) {
+    __vnumber(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(v)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __vsigned(s *string, p *int, v *types.JsonState)
+func vsigned(s *string, p *int, v *types.JsonState) {
+    __vsigned(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(v)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __vunsigned(s *string, p *int, v *types.JsonState)
+func vunsigned(s *string, p *int, v *types.JsonState) {
+    __vunsigned(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(v)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __skip_one(s *string, p *int, m *types.StateMachine, flags uint64) (ret int)
+func skip_one(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) {
+    return __skip_one(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)), flags)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __skip_one_fast(s *string, p *int) (ret int)
+func skip_one_fast(s *string, p *int) (ret int) {
+    return __skip_one_fast(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __skip_array(s *string, p *int, m *types.StateMachine, flags uint64) (ret int)
+func skip_array(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) {
+    return __skip_array(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)), flags)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __skip_object(s *string, p *int, m *types.StateMachine, flags uint64) (ret int)
+func skip_object(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) {
+    return __skip_object(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)), flags)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __skip_number(s *string, p *int) (ret int)
+func skip_number(s *string, p *int) (ret int) {
+    return __skip_number(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __validate_one(s *string, p *int, m *types.StateMachine) (ret int)
+func validate_one(s *string, p *int, m *types.StateMachine) (ret int) {
+    return __validate_one(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __get_by_path(s *string, p *int, path *[]interface{}, m *types.StateMachine) (ret int)
+func get_by_path(s *string, p *int, path *[]interface{}, m *types.StateMachine) (ret int) {
+    return __get_by_path(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(path)), rt.NoEscape(unsafe.Pointer(m)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __validate_utf8(s *string, p *int, m *types.StateMachine) (ret int)
+func validate_utf8(s *string, p *int, m *types.StateMachine) (ret int) {
+    return __validate_utf8(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __validate_utf8_fast(s *string)  (ret int)
+func validate_utf8_fast(s *string)  (ret int) {
+    return __validate_utf8_fast(rt.NoEscape(unsafe.Pointer(s)))
+}
+
+//go:nosplit
+func fsm_exec(m *types.StateMachine, s *string, p *int, flags uint64) (ret int) {
+    return __fsm_exec(rt.NoEscape(unsafe.Pointer(m)), rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), flags)
+}

vendor/github.com/bytedance/sonic/internal/native/native_amd64_test.tmpl

@@ -1,3 +1,5 @@
+// Code generated by Makefile, DO NOT EDIT.
+
 /*
  * Copyright 2021 ByteDance Inc.
  *
@@ -20,6 +22,7 @@ import (
     `encoding/hex`
     `fmt`
     `math`
+    `strings`
     `testing`
     `unsafe`
 
@@ -34,7 +37,7 @@ func TestNative_Value(t *testing.T) {
     var v types.JsonState
     s := `   -12345`
     p := (*rt.GoString)(unsafe.Pointer(&s))
-    x := __value(p.Ptr, p.Len, 0, &v, 0)
+    x := value(p.Ptr, p.Len, 0, &v, 0)
     assert.Equal(t, 9, x)
     assert.Equal(t, types.V_INTEGER, v.Vt)
     assert.Equal(t, int64(-12345), v.Iv)
@@ -46,7 +49,7 @@ func TestNative_Value_OutOfBound(t *testing.T) {
     mem := []byte{'"', '"'}
     s := rt.Mem2Str(mem[:1])
     p := (*rt.GoString)(unsafe.Pointer(&s))
-    x := __value(p.Ptr, p.Len, 0, &v, 0)
+    x := value(p.Ptr, p.Len, 0, &v, 0)
     assert.Equal(t, 1, x)
     assert.Equal(t, -int(types.ERR_EOF), int(v.Vt))
 }
@@ -56,7 +59,7 @@ func TestNative_Quote(t *testing.T) {
     d := make([]byte, 256)
     dp := (*rt.GoSlice)(unsafe.Pointer(&d))
     sp := (*rt.GoString)(unsafe.Pointer(&s))
-    rv := __quote(sp.Ptr, sp.Len, dp.Ptr, &dp.Len, 0)
+    rv := quote(sp.Ptr, sp.Len, dp.Ptr, &dp.Len, 0)
     if rv < 0 {
         require.NoError(t, types.ParsingError(-rv))
     }
@@ -70,7 +73,7 @@ func TestNative_QuoteNoMem(t *testing.T) {
     d := make([]byte, 10)
     dp := (*rt.GoSlice)(unsafe.Pointer(&d))
     sp := (*rt.GoString)(unsafe.Pointer(&s))
-    rv := __quote(sp.Ptr, sp.Len, dp.Ptr, &dp.Len, 0)
+    rv := quote(sp.Ptr, sp.Len, dp.Ptr, &dp.Len, 0)
     assert.Equal(t, -6, rv)
     assert.Equal(t, 5, len(d))
     assert.Equal(t, `hello`, string(d))
@@ -81,7 +84,7 @@ func TestNative_DoubleQuote(t *testing.T) {
     d := make([]byte, 256)
     dp := (*rt.GoSlice)(unsafe.Pointer(&d))
     sp := (*rt.GoString)(unsafe.Pointer(&s))
-    rv := __quote(sp.Ptr, sp.Len, dp.Ptr, &dp.Len, types.F_DOUBLE_UNQUOTE)
+    rv := quote(sp.Ptr, sp.Len, dp.Ptr, &dp.Len, types.F_DOUBLE_UNQUOTE)
     if rv < 0 {
         require.NoError(t, types.ParsingError(-rv))
     }
@@ -96,7 +99,7 @@ func TestNative_Unquote(t *testing.T) {
     ep := -1
     dp := (*rt.GoSlice)(unsafe.Pointer(&d))
     sp := (*rt.GoString)(unsafe.Pointer(&s))
-    rv := __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
+    rv := unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
     if rv < 0 {
         require.NoError(t, types.ParsingError(-rv))
     }
@@ -111,7 +114,7 @@ func TestNative_UnquoteError(t *testing.T) {
     ep := -1
     dp := (*rt.GoSlice)(unsafe.Pointer(&d))
     sp := (*rt.GoString)(unsafe.Pointer(&s))
-    rv := __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
+    rv := unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
     assert.Equal(t, -int(types.ERR_EOF), rv)
     assert.Equal(t, 5, ep)
     s = `asdf\gqwer`
@@ -119,7 +122,7 @@ func TestNative_UnquoteError(t *testing.T) {
     ep = -1
     dp = (*rt.GoSlice)(unsafe.Pointer(&d))
     sp = (*rt.GoString)(unsafe.Pointer(&s))
-    rv = __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
+    rv = unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
     assert.Equal(t, -int(types.ERR_INVALID_ESCAPE), rv)
     assert.Equal(t, 5, ep)
     s = `asdf\u1gggqwer`
@@ -127,7 +130,7 @@ func TestNative_UnquoteError(t *testing.T) {
     ep = -1
     dp = (*rt.GoSlice)(unsafe.Pointer(&d))
     sp = (*rt.GoString)(unsafe.Pointer(&s))
-    rv = __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
+    rv = unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
     assert.Equal(t, -int(types.ERR_INVALID_CHAR), rv)
     assert.Equal(t, 7, ep)
     s = `asdf\ud800qwer`
@@ -135,7 +138,7 @@ func TestNative_UnquoteError(t *testing.T) {
     ep = -1
     dp = (*rt.GoSlice)(unsafe.Pointer(&d))
     sp = (*rt.GoString)(unsafe.Pointer(&s))
-    rv = __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
+    rv = unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
     assert.Equal(t, -int(types.ERR_INVALID_UNICODE), rv)
     assert.Equal(t, 6, ep)
     s = `asdf\\ud800qwer`
@@ -143,7 +146,7 @@ func TestNative_UnquoteError(t *testing.T) {
     ep = -1
     dp = (*rt.GoSlice)(unsafe.Pointer(&d))
     sp = (*rt.GoString)(unsafe.Pointer(&s))
-    rv = __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_DOUBLE_UNQUOTE)
+    rv = unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_DOUBLE_UNQUOTE)
     assert.Equal(t, -int(types.ERR_INVALID_UNICODE), rv)
     assert.Equal(t, 7, ep)
     s = `asdf\ud800\ud800qwer`
@@ -151,7 +154,7 @@ func TestNative_UnquoteError(t *testing.T) {
     ep = -1
     dp = (*rt.GoSlice)(unsafe.Pointer(&d))
     sp = (*rt.GoString)(unsafe.Pointer(&s))
-    rv = __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
+    rv = unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
     assert.Equal(t, -int(types.ERR_INVALID_UNICODE), rv)
     assert.Equal(t, 12, ep)
     s = `asdf\\ud800\\ud800qwer`
@@ -159,7 +162,7 @@ func TestNative_UnquoteError(t *testing.T) {
     ep = -1
     dp = (*rt.GoSlice)(unsafe.Pointer(&d))
     sp = (*rt.GoString)(unsafe.Pointer(&s))
-    rv = __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_DOUBLE_UNQUOTE)
+    rv = unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_DOUBLE_UNQUOTE)
     assert.Equal(t, -int(types.ERR_INVALID_UNICODE), rv)
     assert.Equal(t, 14, ep)
 }
@@ -170,7 +173,7 @@ func TestNative_DoubleUnquote(t *testing.T) {
     ep := -1
     dp := (*rt.GoSlice)(unsafe.Pointer(&d))
     sp := (*rt.GoString)(unsafe.Pointer(&s))
-    rv := __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_DOUBLE_UNQUOTE)
+    rv := unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_DOUBLE_UNQUOTE)
     if rv < 0 {
         require.NoError(t, types.ParsingError(-rv))
     }
@@ -185,7 +188,7 @@ func TestNative_UnquoteUnicodeReplacement(t *testing.T) {
     ep := -1
     dp := (*rt.GoSlice)(unsafe.Pointer(&d))
     sp := (*rt.GoString)(unsafe.Pointer(&s))
-    rv := __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_UNICODE_REPLACE)
+    rv := unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_UNICODE_REPLACE)
     if rv < 0 {
         require.NoError(t, types.ParsingError(-rv))
     }
@@ -197,7 +200,7 @@ func TestNative_UnquoteUnicodeReplacement(t *testing.T) {
     ep = -1
     dp = (*rt.GoSlice)(unsafe.Pointer(&d))
     sp = (*rt.GoString)(unsafe.Pointer(&s))
-    rv = __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_UNICODE_REPLACE)
+    rv = unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_UNICODE_REPLACE)
     if rv < 0 {
         require.NoError(t, types.ParsingError(-rv))
     }
@@ -211,7 +214,7 @@ func TestNative_HTMLEscape(t *testing.T) {
     d := make([]byte, 256)
     dp := (*rt.GoSlice)(unsafe.Pointer(&d))
     sp := (*rt.GoString)(unsafe.Pointer(&s))
-    rv := __html_escape(sp.Ptr, sp.Len, dp.Ptr, &dp.Len)
+    rv := html_escape(sp.Ptr, sp.Len, dp.Ptr, &dp.Len)
     if rv < 0 {
         require.NoError(t, types.ParsingError(-rv))
     }
@@ -225,7 +228,7 @@ func TestNative_HTMLEscapeNoMem(t *testing.T) {
     d := make([]byte, 10)
     dp := (*rt.GoSlice)(unsafe.Pointer(&d))
     sp := (*rt.GoString)(unsafe.Pointer(&s))
-    rv := __html_escape(sp.Ptr, sp.Len, dp.Ptr, &dp.Len)
+    rv := html_escape(sp.Ptr, sp.Len, dp.Ptr, &dp.Len)
     assert.Equal(t, -6, rv)
     assert.Equal(t, 5, len(d))
     assert.Equal(t, `hello`, string(d))
@@ -235,11 +238,11 @@ func TestNative_Vstring(t *testing.T) {
     var v types.JsonState
     i := 0
     s := `test"test\n2"`
-    __vstring(&s, &i, &v, 0)
+    vstring(&s, &i, &v, 0)
     assert.Equal(t, 5, i)
     assert.Equal(t, -1, v.Ep)
     assert.Equal(t, int64(0), v.Iv)
-    __vstring(&s, &i, &v, 0)
+    vstring(&s, &i, &v, 0)
     assert.Equal(t, 13, i)
     assert.Equal(t, 9, v.Ep)
     assert.Equal(t, int64(5), v.Iv)
@@ -250,7 +253,7 @@ func TestNative_Vstring_ValidUnescapedChars(t *testing.T) {
     valid := uint64(types.F_VALIDATE_STRING)
     i := 0
     s := "test\x1f\""
-    __vstring(&s, &i, &v, valid)
+    vstring(&s, &i, &v, valid)
     assert.Equal(t, -int(types.ERR_INVALID_CHAR), int(v.Vt))
 }
 
@@ -258,7 +261,7 @@ func TestNative_VstringEscapeEOF(t *testing.T) {
     var v types.JsonState
     i := 0
     s := `xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxx"x`
-    __vstring(&s, &i, &v, 0)
+    vstring(&s, &i, &v, 0)
     assert.Equal(t, 95, i)
     assert.Equal(t, 63, v.Ep)
     assert.Equal(t, int64(0), v.Iv)
@@ -274,7 +277,7 @@ func TestNative_VstringHangUpOnRandomData(t *testing.T) {
     p := 1
     s := rt.Mem2Str(v)
     var js types.JsonState
-    __vstring(&s, &p, &js, 0)
+    vstring(&s, &p, &js, 0)
     fmt.Printf("js: %s\n", spew.Sdump(js))
 }
 
@@ -282,49 +285,49 @@ func TestNative_Vnumber(t *testing.T) {
     var v types.JsonState
     i := 0
     s := "1234"
-    __vnumber(&s, &i, &v)
+    vnumber(&s, &i, &v)
     assert.Equal(t, 4, i)
     assert.Equal(t, 0, v.Ep)
     assert.Equal(t, int64(1234), v.Iv)
     assert.Equal(t, types.V_INTEGER, v.Vt)
     i = 0
     s = "1.234"
-    __vnumber(&s, &i, &v)
+    vnumber(&s, &i, &v)
     assert.Equal(t, 5, i)
     assert.Equal(t, 0, v.Ep)
     assert.Equal(t, 1.234, v.Dv)
     assert.Equal(t, types.V_DOUBLE, v.Vt)
     i = 0
     s = "1.234e5"
-    __vnumber(&s, &i, &v)
+    vnumber(&s, &i, &v)
     assert.Equal(t, 7, i)
     assert.Equal(t, 0, v.Ep)
     assert.Equal(t, 1.234e5, v.Dv)
     assert.Equal(t, types.V_DOUBLE, v.Vt)
     i = 0
     s = "0.0125"
-    __vnumber(&s, &i, &v)
+    vnumber(&s, &i, &v)
     assert.Equal(t, 6, i)
     assert.Equal(t, 0, v.Ep)
     assert.Equal(t, 0.0125, v.Dv)
     assert.Equal(t, types.V_DOUBLE, v.Vt)
     i = 0
     s = "100000000000000000000"
-    __vnumber(&s, &i, &v)
+    vnumber(&s, &i, &v)
     assert.Equal(t, 21, i)
     assert.Equal(t, 0, v.Ep)
     assert.Equal(t, 100000000000000000000.0, v.Dv)
     assert.Equal(t, types.V_DOUBLE, v.Vt)
     i = 0
     s = "999999999999999900000"
-    __vnumber(&s, &i, &v)
+    vnumber(&s, &i, &v)
     assert.Equal(t, 21, i)
     assert.Equal(t, 0, v.Ep)
     assert.Equal(t, 999999999999999900000.0, v.Dv)
     assert.Equal(t, types.V_DOUBLE, v.Vt)
     i = 0
     s = "-1.234"
-    __vnumber(&s, &i, &v)
+    vnumber(&s, &i, &v)
     assert.Equal(t, 6, i)
     assert.Equal(t, 0, v.Ep)
     assert.Equal(t, -1.234, v.Dv)
@@ -335,65 +338,65 @@ func TestNative_Vsigned(t *testing.T) {
     var v types.JsonState
     i := 0
     s := "1234"
-    __vsigned(&s, &i, &v)
+    vsigned(&s, &i, &v)
     assert.Equal(t, 4, i)
     assert.Equal(t, 0, v.Ep)
     assert.Equal(t, int64(1234), v.Iv)
     assert.Equal(t, types.V_INTEGER, v.Vt)
     i = 0
     s = "-1234"
-    __vsigned(&s, &i, &v)
+    vsigned(&s, &i, &v)
     assert.Equal(t, 5, i)
     assert.Equal(t, 0, v.Ep)
     assert.Equal(t, int64(-1234), v.Iv)
     assert.Equal(t, types.V_INTEGER, v.Vt)
     i = 0
     s = "9223372036854775807"
-    __vsigned(&s, &i, &v)
+    vsigned(&s, &i, &v)
     assert.Equal(t, 19, i)
     assert.Equal(t, 0, v.Ep)
     assert.Equal(t, int64(math.MaxInt64), v.Iv)
     assert.Equal(t, types.V_INTEGER, v.Vt)
     i = 0
     s = "-9223372036854775808"
-    __vsigned(&s, &i, &v)
+    vsigned(&s, &i, &v)
     assert.Equal(t, 20, i)
     assert.Equal(t, 0, v.Ep)
     assert.Equal(t, int64(math.MinInt64), v.Iv)
     assert.Equal(t, types.V_INTEGER, v.Vt)
     i = 0
     s = "9223372036854775808"
-    __vsigned(&s, &i, &v)
+    vsigned(&s, &i, &v)
     assert.Equal(t, 18, i)
     assert.Equal(t, 0, v.Ep)
     assert.Equal(t, types.ValueType(-int(types.ERR_INTEGER_OVERFLOW)), v.Vt)
     i = 0
     s = "-9223372036854775809"
-    __vsigned(&s, &i, &v)
+    vsigned(&s, &i, &v)
     assert.Equal(t, 19, i)
     assert.Equal(t, 0, v.Ep)
     assert.Equal(t, types.ValueType(-int(types.ERR_INTEGER_OVERFLOW)), v.Vt)
     i = 0
     s = "1.234"
-    __vsigned(&s, &i, &v)
+    vsigned(&s, &i, &v)
     assert.Equal(t, 1, i)
     assert.Equal(t, 0, v.Ep)
     assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
     i = 0
     s = "0.0125"
-    __vsigned(&s, &i, &v)
+    vsigned(&s, &i, &v)
     assert.Equal(t, 1, i)
     assert.Equal(t, 0, v.Ep)
     assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
     i = 0
     s = "-1234e5"
-    __vsigned(&s, &i, &v)
+    vsigned(&s, &i, &v)
     assert.Equal(t, 5, i)
     assert.Equal(t, 0, v.Ep)
     assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
     i = 0
     s = "-1234e-5"
-    __vsigned(&s, &i, &v)
+    vsigned(&s, &i, &v)
     assert.Equal(t, 5, i)
     assert.Equal(t, 0, v.Ep)
     assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
@@ -403,63 +406,63 @@ func TestNative_Vunsigned(t *testing.T) {
     var v types.JsonState
     i := 0
     s := "1234"
-    __vunsigned(&s, &i, &v)
+    vunsigned(&s, &i, &v)
     assert.Equal(t, 4, i)
     assert.Equal(t, 0, v.Ep)
     assert.Equal(t, int64(1234), v.Iv)
     assert.Equal(t, types.V_INTEGER, v.Vt)
     i = 0
     s = "18446744073709551615"
-    __vunsigned(&s, &i, &v)
+    vunsigned(&s, &i, &v)
     assert.Equal(t, 20, i)
     assert.Equal(t, 0, v.Ep)
     assert.Equal(t, ^int64(0), v.Iv)
     assert.Equal(t, types.V_INTEGER, v.Vt)
     i = 0
     s = "18446744073709551616"
-    __vunsigned(&s, &i, &v)
+    vunsigned(&s, &i, &v)
     assert.Equal(t, 19, i)
     assert.Equal(t, 0, v.Ep)
     assert.Equal(t, types.ValueType(-int(types.ERR_INTEGER_OVERFLOW)), v.Vt)
     i = 0
     s = "-1234"
-    __vunsigned(&s, &i, &v)
+    vunsigned(&s, &i, &v)
     assert.Equal(t, 0, i)
     assert.Equal(t, 0, v.Ep)
     assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
     i = 0
     s = "1.234"
-    __vunsigned(&s, &i, &v)
+    vunsigned(&s, &i, &v)
     assert.Equal(t, 1, i)
     assert.Equal(t, 0, v.Ep)
     assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
     i = 0
     s = "0.0125"
-    __vunsigned(&s, &i, &v)
+    vunsigned(&s, &i, &v)
     assert.Equal(t, 1, i)
     assert.Equal(t, 0, v.Ep)
     assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
     i = 0
     s = "1234e5"
-    __vunsigned(&s, &i, &v)
+    vunsigned(&s, &i, &v)
     assert.Equal(t, 4, i)
     assert.Equal(t, 0, v.Ep)
     assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
     i = 0
     s = "-1234e5"
-    __vunsigned(&s, &i, &v)
+    vunsigned(&s, &i, &v)
     assert.Equal(t, 0, i)
     assert.Equal(t, 0, v.Ep)
     assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
     i = 0
     s = "-1.234e5"
-    __vunsigned(&s, &i, &v)
+    vunsigned(&s, &i, &v)
     assert.Equal(t, 0, i)
     assert.Equal(t, 0, v.Ep)
     assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
     i = 0
     s = "-1.234e-5"
-    __vunsigned(&s, &i, &v)
+    vunsigned(&s, &i, &v)
     assert.Equal(t, 0, i)
     assert.Equal(t, 0, v.Ep)
     assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
@@ -468,36 +471,36 @@ func TestNative_Vunsigned(t *testing.T) {
 func TestNative_SkipOne(t *testing.T) {
     p := 0
     s := ` {"asdf": [null, true, false, 1, 2.0, -3]}, 1234.5`
-    q := __skip_one(&s, &p, &types.StateMachine{}, uint64(0))
+    q := skip_one(&s, &p, &types.StateMachine{}, uint64(0))
     assert.Equal(t, 42, p)
     assert.Equal(t, 1, q)
     p = 0
     s = `1 2.5 -3 "asdf\nqwer" true false null {} []`
-    q = __skip_one(&s, &p, &types.StateMachine{}, uint64(0))
+    q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
     assert.Equal(t, 1, p)
     assert.Equal(t, 0, q)
-    q = __skip_one(&s, &p, &types.StateMachine{}, uint64(0))
+    q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
     assert.Equal(t, 5, p)
     assert.Equal(t, 2, q)
-    q = __skip_one(&s, &p, &types.StateMachine{}, uint64(0))
+    q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
     assert.Equal(t, 8, p)
     assert.Equal(t, 6, q)
-    q = __skip_one(&s, &p, &types.StateMachine{}, uint64(0))
+    q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
     assert.Equal(t, 21, p)
     assert.Equal(t, 9, q)
-    q = __skip_one(&s, &p, &types.StateMachine{}, uint64(0))
+    q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
     assert.Equal(t, 26, p)
     assert.Equal(t, 22, q)
-    q = __skip_one(&s, &p, &types.StateMachine{}, uint64(0))
+    q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
     assert.Equal(t, 32, p)
     assert.Equal(t, 27, q)
-    q = __skip_one(&s, &p, &types.StateMachine{}, uint64(0))
+    q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
     assert.Equal(t, 37, p)
     assert.Equal(t, 33, q)
-    q = __skip_one(&s, &p, &types.StateMachine{}, uint64(0))
+    q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
     assert.Equal(t, 40, p)
     assert.Equal(t, 38, q)
-    q = __skip_one(&s, &p, &types.StateMachine{}, uint64(0))
+    q = skip_one(&s, &p, &types.StateMachine{}, uint64(0))
     assert.Equal(t, 43, p)
     assert.Equal(t, 41, q)
 }
@@ -509,7 +512,7 @@ func TestNative_SkipOne_Error(t *testing.T) {
         `"asdf`, `"\\\"`,
     }) {
         p := 0
-        q := __skip_one(&s, &p, &types.StateMachine{}, uint64(0))
+        q := skip_one(&s, &p, &types.StateMachine{}, uint64(0))
         assert.True(t, q < 0)
     }
 }
@@ -517,21 +520,21 @@ func TestNative_SkipOne_Error(t *testing.T) {
 func TestNative_SkipArray(t *testing.T) {
     p := 0
     s := `null, true, false, 1, 2.0, -3, {"asdf": "wqer"}],`
-    __skip_array(&s, &p, &types.StateMachine{}, uint64(0))
+    skip_array(&s, &p, &types.StateMachine{}, uint64(0))
     assert.Equal(t, p, 48)
 }
 
 func TestNative_SkipObject(t *testing.T) {
     p := 0
     s := `"asdf": "wqer"},`
-    __skip_object(&s, &p, &types.StateMachine{}, uint64(0))
+    skip_object(&s, &p, &types.StateMachine{}, uint64(0))
     assert.Equal(t, p, 15)
 }
 
 func TestNative_SkipNumber(t *testing.T) {
     p := 0
     s := `-1.23e+12`
-    q := __skip_number(&s, &p)
+    q := skip_number(&s, &p)
     assert.Equal(t, 9, p)
     assert.Equal(t, 0, q)
 }
@@ -539,44 +542,44 @@ func TestNative_SkipNumber(t *testing.T) {
 func TestNative_SkipOneFast(t *testing.T) {
     p := 0
     s := ` {"asdf": [null, true, false, 1, 2.0, -3]}, 1234.5`
-    q := __skip_one_fast(&s, &p)
+    q := skip_one_fast(&s, &p)
     assert.Equal(t, 42, p)
     assert.Equal(t, 1, q)
     p = 0
     s = `1, 2.5, -3, "asdf\nqwer", true, false, null, {}, [],`
-    q = __skip_one_fast(&s, &p)
+    q = skip_one_fast(&s, &p)
     assert.Equal(t, 1, p)
     assert.Equal(t, 0, q)
     p += 1
-    q = __skip_one_fast(&s, &p)
+    q = skip_one_fast(&s, &p)
     assert.Equal(t, 6, p)
     assert.Equal(t, 3, q)
     p += 1
-    q = __skip_one_fast(&s, &p)
+    q = skip_one_fast(&s, &p)
     assert.Equal(t, 10, p)
     assert.Equal(t, 8, q)
     p += 1
-    q = __skip_one_fast(&s, &p)
+    q = skip_one_fast(&s, &p)
     assert.Equal(t, 24, p)
     assert.Equal(t, 12, q)
     p += 1
-    q = __skip_one_fast(&s, &p)
+    q = skip_one_fast(&s, &p)
     assert.Equal(t, 30, p)
     assert.Equal(t, 26, q)
     p += 1
-    q = __skip_one_fast(&s, &p)
+    q = skip_one_fast(&s, &p)
     assert.Equal(t, 37, p)
     assert.Equal(t, 32, q)
     p += 1
-    q = __skip_one_fast(&s, &p)
+    q = skip_one_fast(&s, &p)
     assert.Equal(t, 43, p)
     assert.Equal(t, 39, q)
     p += 1
-    q = __skip_one_fast(&s, &p)
+    q = skip_one_fast(&s, &p)
     assert.Equal(t, 47, p)
     assert.Equal(t, 45, q)
     p += 1
-    q = __skip_one_fast(&s, &p)
+    q = skip_one_fast(&s, &p)
     assert.Equal(t, 51, p)
     assert.Equal(t, 49, q)
 }
@@ -587,7 +590,36 @@ func TestNative_SkipOneFast_Error(t *testing.T) {
         `"asdf`, `"\\\"`,
     }) {
         p := 0
-        q := __skip_one_fast(&s, &p)
+        q := skip_one_fast(&s, &p)
         assert.True(t, q < 0)
     }
 }
+
+func TestNative_GetByPath(t *testing.T) {
+    s := `{"asdf": [null, true, false, 1, 2.0, -3]}, 1234.5`
+    p := 0
+    path := []interface{}{"asdf", 4}
+    ret := get_by_path(&s, &p, &path, types.NewStateMachine())
+    assert.Equal(t, strings.Index(s, "2.0"), ret)
+}
+
+func BenchmarkNative_SkipOneFast(b *testing.B) {
+    b.ResetTimer()
+    for i:=0; i<b.N; i++ {
+        s := `{"asdf": [null, true, false, 1, 2.0, -3]}, 1234.5`
+        p := 0
+        _ = skip_one_fast(&s, &p)
+    }
+}
+
+func BenchmarkNative_GetByPath(b *testing.B) {
+    b.ResetTimer()
+    for i:=0; i<b.N; i++ {
+        s := `{"asdf": [null, true, false, 1, 2.0, -3]}, 1234.5`
+        p := 0
+        path := []interface{}{"asdf", 3}
+        sm := types.NewStateMachine()
+        _ = get_by_path(&s, &p, &path, sm)
+        types.FreeStateMachine(sm)
+    }
+}

vendor/github.com/bytedance/sonic/internal/native/native_export_amd64.tmpl

@@ -1,47 +0,0 @@
-/*
- * Copyright 2021 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 {{PACKAGE}}
-
-var (
-    S_f64toa = _subr__f64toa
-    S_f32toa = _subr__f32toa
-    S_i64toa = _subr__i64toa
-    S_u64toa = _subr__u64toa
-    S_lspace = _subr__lspace
-)
-
-var (
-    S_quote   = _subr__quote
-    S_unquote = _subr__unquote
-)
-
-var (
-    S_value     = _subr__value
-    S_vstring   = _subr__vstring
-    S_vnumber   = _subr__vnumber
-    S_vsigned   = _subr__vsigned
-    S_vunsigned = _subr__vunsigned
-)
-
-var (
-    S_skip_one    = _subr__skip_one
-    S_skip_one_fast = _subr__skip_one_fast
-    S_skip_array  = _subr__skip_array
-    S_skip_object = _subr__skip_object
-    S_skip_number = _subr__skip_number
-    S_get_by_path = _subr__get_by_path
-)

vendor/github.com/bytedance/sonic/internal/native/sse/native_amd64.go

@@ -1,5 +1,7 @@
 // Code generated by Makefile, DO NOT EDIT.
 
+// Code generated by Makefile, DO NOT EDIT.
+
 /*
  * Copyright 2021 ByteDance Inc.
  *
@@ -22,114 +24,168 @@ import (
     `unsafe`
 
     `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+var (
+    __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)
+
+    __lspace func(sp unsafe.Pointer, nb int, off int) (ret int)
+
+    __quote func(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn unsafe.Pointer, flags uint64) (ret int)
+
+    __html_escape func(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn unsafe.Pointer) (ret int)
+
+    __unquote func(sp unsafe.Pointer, nb int, dp unsafe.Pointer, ep unsafe.Pointer, flags uint64) (ret int)
+
+    __value func(s unsafe.Pointer, n int, p int, v unsafe.Pointer, flags uint64) (ret int)
+
+    __vstring func(s unsafe.Pointer, p unsafe.Pointer, v unsafe.Pointer, flags uint64)
+
+    __vnumber func(s unsafe.Pointer, p unsafe.Pointer, v unsafe.Pointer)
+
+    __vsigned func(s unsafe.Pointer, p unsafe.Pointer, v unsafe.Pointer)
+
+    __vunsigned func(s unsafe.Pointer, p unsafe.Pointer, v unsafe.Pointer)
+
+    __skip_one func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer, flags uint64) (ret int)
+
+    __skip_one_fast func(s unsafe.Pointer, p unsafe.Pointer) (ret int)
+
+    __skip_array func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer, flags uint64) (ret int)
+
+    __skip_object func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer, flags uint64) (ret int)
+
+    __skip_number func(s unsafe.Pointer, p unsafe.Pointer) (ret int)
+
+    __validate_one func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer) (ret int)
+
+    __get_by_path func(s unsafe.Pointer, p unsafe.Pointer, path unsafe.Pointer, m unsafe.Pointer) (ret int)
+
+    __validate_utf8 func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer) (ret int)
+
+    __validate_utf8_fast func(s unsafe.Pointer)  (ret int)
+
+    __fsm_exec func(m unsafe.Pointer, s unsafe.Pointer, p unsafe.Pointer, flags uint64) (ret int)
 )
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __i64toa(out *byte, val int64) (ret int)
+func i64toa(out *byte, val int64) (ret int) {
+    return __i64toa(rt.NoEscape(unsafe.Pointer(out)), val)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __u64toa(out *byte, val uint64) (ret int)
+func u64toa(out *byte, val uint64) (ret int) {
+    return __u64toa(rt.NoEscape(unsafe.Pointer(out)), val)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __f64toa(out *byte, val float64) (ret int)
+func f64toa(out *byte, val float64) (ret int) {
+    return __f64toa(rt.NoEscape(unsafe.Pointer(out)), val)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __f32toa(out *byte, val float32) (ret int)
+func f32toa(out *byte, val float32) (ret int) {
+    return __f32toa(rt.NoEscape(unsafe.Pointer(out)), val)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __lspace(sp unsafe.Pointer, nb int, off int) (ret int)
+func lspace(sp unsafe.Pointer, nb int, off int) (ret int) {
+    return __lspace(rt.NoEscape(sp), nb, off)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __quote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int, flags uint64) (ret int)
+func quote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int, flags uint64) (ret int) {
+    return __quote(rt.NoEscape(unsafe.Pointer(sp)), nb, rt.NoEscape(unsafe.Pointer(dp)), rt.NoEscape(unsafe.Pointer(dn)), flags)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __html_escape(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int) (ret int)
+func html_escape(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int) (ret int) {
+    return __html_escape(rt.NoEscape(unsafe.Pointer(sp)), nb, rt.NoEscape(unsafe.Pointer(dp)), rt.NoEscape(unsafe.Pointer(dn)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __unquote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, ep *int, flags uint64) (ret int)
+func unquote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, ep *int, flags uint64) (ret int) {
+    return __unquote(rt.NoEscape(unsafe.Pointer(sp)), nb, rt.NoEscape(unsafe.Pointer(dp)), rt.NoEscape(unsafe.Pointer(ep)), flags)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __value(s unsafe.Pointer, n int, p int, v *types.JsonState, flags uint64) (ret int)
+func value(s unsafe.Pointer, n int, p int, v *types.JsonState, flags uint64) (ret int) {
+    return __value(rt.NoEscape(unsafe.Pointer(s)), n, p, rt.NoEscape(unsafe.Pointer(v)), flags)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __vstring(s *string, p *int, v *types.JsonState, flags uint64)
+func vstring(s *string, p *int, v *types.JsonState, flags uint64) {
+    __vstring(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(v)), flags)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __vnumber(s *string, p *int, v *types.JsonState)
+func vnumber(s *string, p *int, v *types.JsonState) {
+    __vnumber(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(v)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __vsigned(s *string, p *int, v *types.JsonState)
+func vsigned(s *string, p *int, v *types.JsonState) {
+    __vsigned(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(v)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __vunsigned(s *string, p *int, v *types.JsonState)
+func vunsigned(s *string, p *int, v *types.JsonState) {
+    __vunsigned(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(v)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __skip_one(s *string, p *int, m *types.StateMachine, flags uint64) (ret int)
+func skip_one(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) {
+    return __skip_one(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)), flags)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __skip_one_fast(s *string, p *int) (ret int)
+func skip_one_fast(s *string, p *int) (ret int) {
+    return __skip_one_fast(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __skip_array(s *string, p *int, m *types.StateMachine, flags uint64) (ret int)
+func skip_array(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) {
+    return __skip_array(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)), flags)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __skip_object(s *string, p *int, m *types.StateMachine, flags uint64) (ret int)
+func skip_object(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) {
+    return __skip_object(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)), flags)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __skip_number(s *string, p *int) (ret int)
+func skip_number(s *string, p *int) (ret int) {
+    return __skip_number(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __validate_one(s *string, p *int, m *types.StateMachine) (ret int)
+func validate_one(s *string, p *int, m *types.StateMachine) (ret int) {
+    return __validate_one(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __get_by_path(s *string, p *int, path *[]interface{}, m *types.StateMachine) (ret int)
+func get_by_path(s *string, p *int, path *[]interface{}, m *types.StateMachine) (ret int) {
+    return __get_by_path(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(path)), rt.NoEscape(unsafe.Pointer(m)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __validate_utf8(s *string, p *int, m *types.StateMachine) (ret int)
+func validate_utf8(s *string, p *int, m *types.StateMachine) (ret int) {
+    return __validate_utf8(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)))
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __validate_utf8_fast(s *string)  (ret int)
+func validate_utf8_fast(s *string)  (ret int) {
+    return __validate_utf8_fast(rt.NoEscape(unsafe.Pointer(s)))
+}
+
+//go:nosplit
+func fsm_exec(m *types.StateMachine, s *string, p *int, flags uint64) (ret int) {
+    return __fsm_exec(rt.NoEscape(unsafe.Pointer(m)), rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), flags)
+}

vendor/github.com/bytedance/sonic/internal/native/sse/native_export_amd64.go

@@ -1,49 +0,0 @@
-// Code generated by Makefile, DO NOT EDIT.
-
-/*
- * Copyright 2021 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 sse
-
-var (
-    S_f64toa = _subr__f64toa
-    S_f32toa = _subr__f32toa
-    S_i64toa = _subr__i64toa
-    S_u64toa = _subr__u64toa
-    S_lspace = _subr__lspace
-)
-
-var (
-    S_quote   = _subr__quote
-    S_unquote = _subr__unquote
-)
-
-var (
-    S_value     = _subr__value
-    S_vstring   = _subr__vstring
-    S_vnumber   = _subr__vnumber
-    S_vsigned   = _subr__vsigned
-    S_vunsigned = _subr__vunsigned
-)
-
-var (
-    S_skip_one    = _subr__skip_one
-    S_skip_one_fast = _subr__skip_one_fast
-    S_skip_array  = _subr__skip_array
-    S_skip_object = _subr__skip_object
-    S_skip_number = _subr__skip_number
-    S_get_by_path = _subr__get_by_path
-)

vendor/github.com/bytedance/sonic/internal/native/sse/native_subr_amd64.go

@@ -3,107 +3,602 @@
 
 package sse
 
-//go:nosplit
-//go:noescape
-//goland:noinspection ALL
-func __native_entry__() uintptr
+import (
+	`github.com/bytedance/sonic/loader`
+)
 
-var (
-    _subr__f32toa             = __native_entry__() + 31760
-    _subr__f64toa             = __native_entry__() + 160
-    _subr__get_by_path        = __native_entry__() + 26384
-    _subr__html_escape        = __native_entry__() + 9072
-    _subr__i64toa             = __native_entry__() + 3424
-    _subr__lspace             = __native_entry__() + 16
-    _subr__quote              = __native_entry__() + 4864
-    _subr__skip_array         = __native_entry__() + 18112
-    _subr__skip_number        = __native_entry__() + 22128
-    _subr__skip_object        = __native_entry__() + 20512
-    _subr__skip_one           = __native_entry__() + 22288
-    _subr__skip_one_fast      = __native_entry__() + 22512
-    _subr__u64toa             = __native_entry__() + 3552
-    _subr__unquote            = __native_entry__() + 6704
-    _subr__validate_one       = __native_entry__() + 22336
-    _subr__validate_utf8      = __native_entry__() + 30528
-    _subr__validate_utf8_fast = __native_entry__() + 31200
-    _subr__value              = __native_entry__() + 12272
-    _subr__vnumber            = __native_entry__() + 15728
-    _subr__vsigned            = __native_entry__() + 17376
-    _subr__vstring            = __native_entry__() + 14112
-    _subr__vunsigned          = __native_entry__() + 17760
+const (
+    _entry__f32toa = 31616
+    _entry__f64toa = 160
+    _entry__format_significand = 35888
+    _entry__format_integer = 2960
+    _entry__fsm_exec = 18016
+    _entry__advance_string = 14352
+    _entry__advance_string_default = 37280
+    _entry__do_skip_number = 20608
+    _entry__get_by_path = 26176
+    _entry__skip_one_fast = 22272
+    _entry__html_escape = 8912
+    _entry__i64toa = 3392
+    _entry__u64toa = 3520
+    _entry__lspace = 16
+    _entry__quote = 4832
+    _entry__skip_array = 17984
+    _entry__skip_number = 21904
+    _entry__skip_object = 20256
+    _entry__skip_one = 22048
+    _entry__unquote = 6576
+    _entry__validate_one = 22096
+    _entry__validate_utf8 = 30384
+    _entry__validate_utf8_fast = 31056
+    _entry__value = 12352
+    _entry__vnumber = 15744
+    _entry__atof_eisel_lemire64 = 10192
+    _entry__atof_native = 11744
+    _entry__decimal_to_f64 = 10560
+    _entry__right_shift = 36848
+    _entry__left_shift = 36352
+    _entry__vsigned = 17296
+    _entry__vstring = 14176
+    _entry__vunsigned = 17632
 )
 
 const (
     _stack__f32toa = 48
     _stack__f64toa = 80
-    _stack__get_by_path = 240
-    _stack__html_escape = 64
+    _stack__format_significand = 24
+    _stack__format_integer = 16
+    _stack__fsm_exec = 168
+    _stack__advance_string = 64
+    _stack__advance_string_default = 64
+    _stack__do_skip_number = 48
+    _stack__get_by_path = 272
+    _stack__skip_one_fast = 136
+    _stack__html_escape = 72
     _stack__i64toa = 16
+    _stack__u64toa = 8
     _stack__lspace = 8
     _stack__quote = 64
-    _stack__skip_array = 128
-    _stack__skip_number = 72
-    _stack__skip_object = 128
-    _stack__skip_one = 128
-    _stack__skip_one_fast = 136
-    _stack__u64toa = 8
+    _stack__skip_array = 176
+    _stack__skip_number = 88
+    _stack__skip_object = 176
+    _stack__skip_one = 176
     _stack__unquote = 88
-    _stack__validate_one = 128
+    _stack__validate_one = 176
     _stack__validate_utf8 = 48
     _stack__validate_utf8_fast = 24
     _stack__value = 328
     _stack__vnumber = 240
+    _stack__atof_eisel_lemire64 = 32
+    _stack__atof_native = 136
+    _stack__decimal_to_f64 = 80
+    _stack__right_shift = 8
+    _stack__left_shift = 24
     _stack__vsigned = 16
-    _stack__vstring = 136
-    _stack__vunsigned = 16
-)
-
-var (
-    _ = _subr__f32toa
-    _ = _subr__f64toa
-    _ = _subr__get_by_path
-    _ = _subr__html_escape
-    _ = _subr__i64toa
-    _ = _subr__lspace
-    _ = _subr__quote
-    _ = _subr__skip_array
-    _ = _subr__skip_number
-    _ = _subr__skip_object
-    _ = _subr__skip_one
-    _ = _subr__skip_one_fast
-    _ = _subr__u64toa
-    _ = _subr__unquote
-    _ = _subr__validate_one
-    _ = _subr__validate_utf8
-    _ = _subr__validate_utf8_fast
-    _ = _subr__value
-    _ = _subr__vnumber
-    _ = _subr__vsigned
-    _ = _subr__vstring
-    _ = _subr__vunsigned
+    _stack__vstring = 120
+    _stack__vunsigned = 8
 )
 
 const (
-    _ = _stack__f32toa
-    _ = _stack__f64toa
-    _ = _stack__get_by_path
-    _ = _stack__html_escape
-    _ = _stack__i64toa
-    _ = _stack__lspace
-    _ = _stack__quote
-    _ = _stack__skip_array
-    _ = _stack__skip_number
-    _ = _stack__skip_object
-    _ = _stack__skip_one
-    _ = _stack__skip_one_fast
-    _ = _stack__u64toa
-    _ = _stack__unquote
-    _ = _stack__validate_one
-    _ = _stack__validate_utf8
-    _ = _stack__validate_utf8_fast
-    _ = _stack__value
-    _ = _stack__vnumber
-    _ = _stack__vsigned
-    _ = _stack__vstring
-    _ = _stack__vunsigned
+    _size__f32toa = 3328
+    _size__f64toa = 2800
+    _size__format_significand = 464
+    _size__format_integer = 432
+    _size__fsm_exec = 1692
+    _size__advance_string = 1344
+    _size__advance_string_default = 960
+    _size__do_skip_number = 956
+    _size__get_by_path = 4208
+    _size__skip_one_fast = 3404
+    _size__html_escape = 1280
+    _size__i64toa = 48
+    _size__u64toa = 1264
+    _size__lspace = 128
+    _size__quote = 1728
+    _size__skip_array = 32
+    _size__skip_number = 144
+    _size__skip_object = 32
+    _size__skip_one = 48
+    _size__unquote = 2272
+    _size__validate_one = 48
+    _size__validate_utf8 = 672
+    _size__validate_utf8_fast = 544
+    _size__value = 1316
+    _size__vnumber = 1552
+    _size__atof_eisel_lemire64 = 368
+    _size__atof_native = 608
+    _size__decimal_to_f64 = 1184
+    _size__right_shift = 400
+    _size__left_shift = 496
+    _size__vsigned = 336
+    _size__vstring = 128
+    _size__vunsigned = 336
 )
+
+var (
+    _pcsp__f32toa = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {3286, 48},
+        {3287, 40},
+        {3289, 32},
+        {3291, 24},
+        {3293, 16},
+        {3295, 8},
+        {3296, 0},
+        {3318, 48},
+    }
+    _pcsp__f64toa = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {2740, 56},
+        {2744, 48},
+        {2745, 40},
+        {2747, 32},
+        {2749, 24},
+        {2751, 16},
+        {2753, 8},
+        {2754, 0},
+        {2792, 56},
+    }
+    _pcsp__format_significand = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {452, 24},
+        {453, 16},
+        {455, 8},
+        {457, 0},
+    }
+    _pcsp__format_integer = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {412, 16},
+        {413, 8},
+        {414, 0},
+        {423, 16},
+        {424, 8},
+        {426, 0},
+    }
+    _pcsp__fsm_exec = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {1342, 104},
+        {1346, 48},
+        {1347, 40},
+        {1349, 32},
+        {1351, 24},
+        {1353, 16},
+        {1355, 8},
+        {1356, 0},
+        {1692, 104},
+    }
+    _pcsp__advance_string = [][2]uint32{
+        {14, 0},
+        {18, 8},
+        {20, 16},
+        {22, 24},
+        {24, 32},
+        {26, 40},
+        {27, 48},
+        {614, 56},
+        {618, 48},
+        {619, 40},
+        {621, 32},
+        {623, 24},
+        {625, 16},
+        {627, 8},
+        {628, 0},
+        {1339, 56},
+    }
+    _pcsp__advance_string_default = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {576, 64},
+        {580, 48},
+        {581, 40},
+        {583, 32},
+        {585, 24},
+        {587, 16},
+        {589, 8},
+        {590, 0},
+        {955, 64},
+    }
+    _pcsp__do_skip_number = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {881, 48},
+        {882, 40},
+        {884, 32},
+        {886, 24},
+        {888, 16},
+        {890, 8},
+        {891, 0},
+        {956, 48},
+    }
+    _pcsp__get_by_path = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {4012, 104},
+        {4016, 48},
+        {4017, 40},
+        {4019, 32},
+        {4021, 24},
+        {4023, 16},
+        {4025, 8},
+        {4026, 0},
+        {4194, 104},
+    }
+    _pcsp__skip_one_fast = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {658, 136},
+        {662, 48},
+        {663, 40},
+        {665, 32},
+        {667, 24},
+        {669, 16},
+        {671, 8},
+        {672, 0},
+        {3404, 136},
+    }
+    _pcsp__html_escape = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {1256, 72},
+        {1260, 48},
+        {1261, 40},
+        {1263, 32},
+        {1265, 24},
+        {1267, 16},
+        {1269, 8},
+        {1271, 0},
+    }
+    _pcsp__i64toa = [][2]uint32{
+        {14, 0},
+        {34, 8},
+        {36, 0},
+    }
+    _pcsp__u64toa = [][2]uint32{
+        {1, 0},
+        {161, 8},
+        {162, 0},
+        {457, 8},
+        {458, 0},
+        {772, 8},
+        {773, 0},
+        {1249, 8},
+        {1251, 0},
+    }
+    _pcsp__lspace = [][2]uint32{
+        {1, 0},
+        {89, 8},
+        {90, 0},
+        {103, 8},
+        {104, 0},
+        {111, 8},
+        {113, 0},
+    }
+    _pcsp__quote = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {1681, 64},
+        {1685, 48},
+        {1686, 40},
+        {1688, 32},
+        {1690, 24},
+        {1692, 16},
+        {1694, 8},
+        {1695, 0},
+        {1722, 64},
+    }
+    _pcsp__skip_array = [][2]uint32{
+        {1, 0},
+        {26, 8},
+        {32, 0},
+    }
+    _pcsp__skip_number = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {100, 40},
+        {101, 32},
+        {103, 24},
+        {105, 16},
+        {107, 8},
+        {108, 0},
+        {139, 40},
+    }
+    _pcsp__skip_object = [][2]uint32{
+        {1, 0},
+        {26, 8},
+        {32, 0},
+    }
+    _pcsp__skip_one = [][2]uint32{
+        {1, 0},
+        {30, 8},
+        {36, 0},
+    }
+    _pcsp__unquote = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {1684, 88},
+        {1688, 48},
+        {1689, 40},
+        {1691, 32},
+        {1693, 24},
+        {1695, 16},
+        {1697, 8},
+        {1698, 0},
+        {2270, 88},
+    }
+    _pcsp__validate_one = [][2]uint32{
+        {1, 0},
+        {35, 8},
+        {41, 0},
+    }
+    _pcsp__validate_utf8 = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {11, 40},
+        {623, 48},
+        {627, 40},
+        {628, 32},
+        {630, 24},
+        {632, 16},
+        {634, 8},
+        {635, 0},
+        {666, 48},
+    }
+    _pcsp__validate_utf8_fast = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {5, 16},
+        {247, 24},
+        {251, 16},
+        {252, 8},
+        {253, 0},
+        {527, 24},
+        {531, 16},
+        {532, 8},
+        {534, 0},
+    }
+    _pcsp__value = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {495, 88},
+        {499, 48},
+        {500, 40},
+        {502, 32},
+        {504, 24},
+        {506, 16},
+        {508, 8},
+        {509, 0},
+        {1316, 88},
+    }
+    _pcsp__vnumber = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {803, 104},
+        {807, 48},
+        {808, 40},
+        {810, 32},
+        {812, 24},
+        {814, 16},
+        {816, 8},
+        {817, 0},
+        {1551, 104},
+    }
+    _pcsp__atof_eisel_lemire64 = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {292, 32},
+        {293, 24},
+        {295, 16},
+        {297, 8},
+        {298, 0},
+        {362, 32},
+    }
+    _pcsp__atof_native = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {587, 56},
+        {591, 8},
+        {593, 0},
+    }
+    _pcsp__decimal_to_f64 = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {1144, 56},
+        {1148, 48},
+        {1149, 40},
+        {1151, 32},
+        {1153, 24},
+        {1155, 16},
+        {1157, 8},
+        {1158, 0},
+        {1169, 56},
+    }
+    _pcsp__right_shift = [][2]uint32{
+        {1, 0},
+        {318, 8},
+        {319, 0},
+        {387, 8},
+        {388, 0},
+        {396, 8},
+        {398, 0},
+    }
+    _pcsp__left_shift = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {363, 24},
+        {364, 16},
+        {366, 8},
+        {367, 0},
+        {470, 24},
+        {471, 16},
+        {473, 8},
+        {474, 0},
+        {486, 24},
+    }
+    _pcsp__vsigned = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {119, 16},
+        {120, 8},
+        {121, 0},
+        {132, 16},
+        {133, 8},
+        {134, 0},
+        {276, 16},
+        {277, 8},
+        {278, 0},
+        {282, 16},
+        {283, 8},
+        {284, 0},
+        {322, 16},
+        {323, 8},
+        {324, 0},
+        {332, 16},
+        {333, 8},
+        {335, 0},
+    }
+    _pcsp__vstring = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {11, 40},
+        {105, 56},
+        {109, 40},
+        {110, 32},
+        {112, 24},
+        {114, 16},
+        {116, 8},
+        {118, 0},
+    }
+    _pcsp__vunsigned = [][2]uint32{
+        {1, 0},
+        {78, 8},
+        {79, 0},
+        {90, 8},
+        {91, 0},
+        {114, 8},
+        {115, 0},
+        {273, 8},
+        {274, 0},
+        {312, 8},
+        {313, 0},
+        {320, 8},
+        {322, 0},
+    }
+)
+
+var Funcs = []loader.CFunc{
+    {"__native_entry__", 0, 67, 0, nil},
+    {"_f32toa", _entry__f32toa, _size__f32toa, _stack__f32toa, _pcsp__f32toa},
+    {"_f64toa", _entry__f64toa, _size__f64toa, _stack__f64toa, _pcsp__f64toa},
+    {"_format_significand", _entry__format_significand, _size__format_significand, _stack__format_significand, _pcsp__format_significand},
+    {"_format_integer", _entry__format_integer, _size__format_integer, _stack__format_integer, _pcsp__format_integer},
+    {"_fsm_exec", _entry__fsm_exec, _size__fsm_exec, _stack__fsm_exec, _pcsp__fsm_exec},
+    {"_advance_string", _entry__advance_string, _size__advance_string, _stack__advance_string, _pcsp__advance_string},
+    {"_advance_string_default", _entry__advance_string_default, _size__advance_string_default, _stack__advance_string_default, _pcsp__advance_string_default},
+    {"_do_skip_number", _entry__do_skip_number, _size__do_skip_number, _stack__do_skip_number, _pcsp__do_skip_number},
+    {"_get_by_path", _entry__get_by_path, _size__get_by_path, _stack__get_by_path, _pcsp__get_by_path},
+    {"_skip_one_fast", _entry__skip_one_fast, _size__skip_one_fast, _stack__skip_one_fast, _pcsp__skip_one_fast},
+    {"_html_escape", _entry__html_escape, _size__html_escape, _stack__html_escape, _pcsp__html_escape},
+    {"_i64toa", _entry__i64toa, _size__i64toa, _stack__i64toa, _pcsp__i64toa},
+    {"_u64toa", _entry__u64toa, _size__u64toa, _stack__u64toa, _pcsp__u64toa},
+    {"_lspace", _entry__lspace, _size__lspace, _stack__lspace, _pcsp__lspace},
+    {"_quote", _entry__quote, _size__quote, _stack__quote, _pcsp__quote},
+    {"_skip_array", _entry__skip_array, _size__skip_array, _stack__skip_array, _pcsp__skip_array},
+    {"_skip_number", _entry__skip_number, _size__skip_number, _stack__skip_number, _pcsp__skip_number},
+    {"_skip_object", _entry__skip_object, _size__skip_object, _stack__skip_object, _pcsp__skip_object},
+    {"_skip_one", _entry__skip_one, _size__skip_one, _stack__skip_one, _pcsp__skip_one},
+    {"_unquote", _entry__unquote, _size__unquote, _stack__unquote, _pcsp__unquote},
+    {"_validate_one", _entry__validate_one, _size__validate_one, _stack__validate_one, _pcsp__validate_one},
+    {"_validate_utf8", _entry__validate_utf8, _size__validate_utf8, _stack__validate_utf8, _pcsp__validate_utf8},
+    {"_validate_utf8_fast", _entry__validate_utf8_fast, _size__validate_utf8_fast, _stack__validate_utf8_fast, _pcsp__validate_utf8_fast},
+    {"_value", _entry__value, _size__value, _stack__value, _pcsp__value},
+    {"_vnumber", _entry__vnumber, _size__vnumber, _stack__vnumber, _pcsp__vnumber},
+    {"_atof_eisel_lemire64", _entry__atof_eisel_lemire64, _size__atof_eisel_lemire64, _stack__atof_eisel_lemire64, _pcsp__atof_eisel_lemire64},
+    {"_atof_native", _entry__atof_native, _size__atof_native, _stack__atof_native, _pcsp__atof_native},
+    {"_decimal_to_f64", _entry__decimal_to_f64, _size__decimal_to_f64, _stack__decimal_to_f64, _pcsp__decimal_to_f64},
+    {"_right_shift", _entry__right_shift, _size__right_shift, _stack__right_shift, _pcsp__right_shift},
+    {"_left_shift", _entry__left_shift, _size__left_shift, _stack__left_shift, _pcsp__left_shift},
+    {"_vsigned", _entry__vsigned, _size__vsigned, _stack__vsigned, _pcsp__vsigned},
+    {"_vstring", _entry__vstring, _size__vstring, _stack__vstring, _pcsp__vstring},
+    {"_vunsigned", _entry__vunsigned, _size__vunsigned, _stack__vunsigned, _pcsp__vunsigned},
+}

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

@@ -19,6 +19,7 @@ package types
 import (
     `fmt`
     `sync`
+    `unsafe`
 )
 
 type ValueType int
@@ -46,15 +47,23 @@ 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 (
@@ -136,3 +145,18 @@ 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/resolver/stubs.go

@@ -1,46 +0,0 @@
-/*
- * Copyright 2021 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 resolver
-
-import (
-    _ `encoding/json`
-    `reflect`
-    _ `unsafe`
-)
-
-type StdField struct {
-    name        string
-    nameBytes   []byte
-    equalFold   func()
-    nameNonEsc  string
-    nameEscHTML string
-    tag         bool
-    index       []int
-    typ         reflect.Type
-    omitEmpty   bool
-    quoted      bool
-    encoder     func()
-}
-
-type StdStructFields struct {
-    list      []StdField
-    nameIndex map[string]int
-}
-
-//go:noescape
-//go:linkname typeFields encoding/json.typeFields
-func typeFields(_ reflect.Type) StdStructFields

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

@@ -110,3 +110,15 @@ func StrFrom(p unsafe.Pointer, n int64) (s string) {
     (*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/loader/funcdata.go

@@ -42,6 +42,13 @@ const (
     _SUB_BUCKETSIZE = _BUCKETSIZE / _SUBBUCKETS
 )
 
+// Note: This list must match the list in runtime/symtab.go.
+const (
+	FuncFlag_TOPFRAME = 1 << iota
+	FuncFlag_SPWRITE
+	FuncFlag_ASM
+)
+
 // PCDATA and FUNCDATA table indexes.
 //
 // See funcdata.h and $GROOT/src/cmd/internal/objabi/funcdata.go.
@@ -142,3 +149,97 @@ func funcNameParts(name string) (string, string, string) {
     }
     return name[:i], "[...]", name[j+1:]
 }
+
+
+// func name table format: 
+//   nameOff[0] -> namePartA namePartB namePartC \x00 
+//   nameOff[1] -> namePartA namePartB namePartC \x00
+//  ...
+func makeFuncnameTab(funcs []Func) (tab []byte, offs []int32) {
+    offs = make([]int32, len(funcs))
+    offset := 1
+    tab = []byte{0}
+
+    for i, f := range funcs {
+        offs[i] = int32(offset)
+
+        a, b, c := funcNameParts(f.Name)
+        tab = append(tab, a...)
+        tab = append(tab, b...)
+        tab = append(tab, c...)
+        tab = append(tab, 0)
+        offset += len(a) + len(b) + len(c) + 1
+    }
+
+    return
+}
+
+// CU table format:
+//  cuOffsets[0] -> filetabOffset[0] filetabOffset[1] ... filetabOffset[len(CUs[0].fileNames)-1]
+//  cuOffsets[1] -> filetabOffset[len(CUs[0].fileNames)] ... filetabOffset[len(CUs[0].fileNames) + len(CUs[1].fileNames)-1]
+//  ...
+//
+// file name table format:
+//  filetabOffset[0] -> CUs[0].fileNames[0] \x00
+//  ...
+//  filetabOffset[len(CUs[0]-1)] -> CUs[0].fileNames[len(CUs[0].fileNames)-1] \x00
+//  ...
+//  filetabOffset[SUM(CUs,fileNames)-1] -> CUs[len(CU)-1].fileNames[len(CUs[len(CU)-1].fileNames)-1] \x00
+func makeFilenametab(cus []compilationUnit) (cutab []uint32, filetab []byte, cuOffsets []uint32) {
+    cuOffsets = make([]uint32, len(cus))
+    cuOffset := 0
+    fileOffset := 0
+
+    for i, cu := range cus {
+        cuOffsets[i] = uint32(cuOffset)
+
+        for _, name := range cu.fileNames {
+            cutab = append(cutab, uint32(fileOffset))
+
+            fileOffset += len(name) + 1
+            filetab = append(filetab, name...)
+            filetab = append(filetab, 0)
+        }
+
+        cuOffset += len(cu.fileNames)
+    }
+
+    return
+}
+
+func writeFuncdata(out *[]byte, funcs []Func) (fstart int, funcdataOffs [][]uint32) {
+    fstart = len(*out)
+    *out = append(*out, byte(0))
+    offs := uint32(1)
+
+    funcdataOffs = make([][]uint32, len(funcs))
+    for i, f := range funcs {
+
+        var writer = func(fd encoding.BinaryMarshaler) {
+            var ab []byte
+            var err error
+            if fd != nil {
+                ab, err = fd.MarshalBinary()
+                if err != nil {
+                    panic(err)
+                }
+                funcdataOffs[i] = append(funcdataOffs[i], offs)
+            } else {
+                ab = []byte{0}
+                funcdataOffs[i] = append(funcdataOffs[i], _INVALID_FUNCDATA_OFFSET)
+            }
+            *out = append(*out, ab...)
+            offs += uint32(len(ab))
+        }
+
+        writer(f.ArgsPointerMaps)
+        writer(f.LocalsPointerMaps)
+        writer(f.StackObjects)
+        writer(f.InlTree)
+        writer(f.OpenCodedDeferInfo)
+        writer(f.ArgInfo)
+        writer(f.ArgLiveInfo)
+        writer(f.WrapInfo)
+    }
+    return 
+}

vendor/github.com/bytedance/sonic/loader/funcdata_go115.go

@@ -1,549 +0,0 @@
-//go:build go1.15 && !go1.16
-// +build go1.15,!go1.16
-
-/*
- * Copyright 2021 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 (
-    `encoding`
-    `os`
-    `unsafe`
-
-    `github.com/bytedance/sonic/internal/rt`
-)
-
-const (
-    _Magic uint32 = 0xfffffffa
-)
-
-type pcHeader struct {
-    magic          uint32  // 0xFFFFFFF0
-    pad1, pad2     uint8   // 0,0
-    minLC          uint8   // min instruction size
-    ptrSize        uint8   // size of a ptr in bytes
-    nfunc          int     // number of functions in the module
-    nfiles         uint    // number of entries in the file tab
-    funcnameOffset uintptr // offset to the funcnametab variable from pcHeader
-    cuOffset       uintptr // offset to the cutab variable from pcHeader
-    filetabOffset  uintptr // offset to the filetab variable from pcHeader
-    pctabOffset    uintptr // offset to the pctab variable from pcHeader
-    pclnOffset     uintptr // offset to the pclntab variable from pcHeader
-}
-
-type moduledata struct {
-    pcHeader     *pcHeader
-    funcnametab  []byte
-    cutab        []uint32
-    filetab      []byte
-    pctab        []byte
-    pclntable    []byte
-    ftab         []funcTab
-    findfunctab  uintptr
-    minpc, maxpc uintptr // first func address, last func address + last func size
-
-    text, etext           uintptr // start/end of text, (etext-text) must be greater than MIN_FUNC
-    noptrdata, enoptrdata uintptr
-    data, edata           uintptr
-    bss, ebss             uintptr
-    noptrbss, enoptrbss   uintptr
-    end, gcdata, gcbss    uintptr
-    types, etypes         uintptr
-    
-    textsectmap []textSection // see runtime/symtab.go: textAddr()
-    typelinks   []int32 // offsets from types
-    itablinks   []*rt.GoItab
-
-    ptab []ptabEntry
-
-    pluginpath string
-    pkghashes  []modulehash
-
-    modulename   string
-    modulehashes []modulehash
-
-    hasmain uint8 // 1 if module contains the main function, 0 otherwise
-
-    gcdatamask, gcbssmask bitVector
-
-    typemap map[int32]*rt.GoType // offset to *_rtype in previous module
-
-    bad bool // module failed to load and should be ignored
-
-    next *moduledata
-}
-
-type _func struct {
-    entry    uintptr // start pc, as offset from moduledata.text/pcHeader.textStart
-    nameOff  int32  // function name, as index into moduledata.funcnametab.
-
-    args        int32  // in/out args size
-    deferreturn uint32 // offset of start of a deferreturn call instruction from entry, if any.
-
-    pcsp      uint32 
-    pcfile    uint32
-    pcln      uint32
-    npcdata   uint32
-    cuOffset  uint32 // runtime.cutab offset of this function's CU
-    funcID    uint8  // set for certain special runtime functions
-    _         [2]byte // pad
-    nfuncdata uint8   // 
-    
-    // The end of the struct is followed immediately by two variable-length
-    // arrays that reference the pcdata and funcdata locations for this
-    // function.
-
-    // pcdata contains the offset into moduledata.pctab for the start of
-    // that index's table. e.g.,
-    // &moduledata.pctab[_func.pcdata[_PCDATA_UnsafePoint]] is the start of
-    // the unsafe point table.
-    //
-    // An offset of 0 indicates that there is no table.
-    //
-    // pcdata [npcdata]uint32
-
-    // funcdata contains the offset past moduledata.gofunc which contains a
-    // pointer to that index's funcdata. e.g.,
-    // *(moduledata.gofunc +  _func.funcdata[_FUNCDATA_ArgsPointerMaps]) is
-    // the argument pointer map.
-    //
-    // An offset of ^uint32(0) indicates that there is no entry.
-    //
-    // funcdata [nfuncdata]uint32
-}
-
-type funcTab struct {
-    entry   uintptr
-    funcoff uintptr
-}
-
-type bitVector struct {
-    n        int32 // # of bits
-    bytedata *uint8
-}
-
-type ptabEntry struct {
-    name int32
-    typ  int32
-}
-
-type textSection struct {
-    vaddr    uintptr // prelinked section vaddr
-    end      uintptr // vaddr + section length
-    baseaddr uintptr // relocated section address
-}
-
-type modulehash struct {
-    modulename   string
-    linktimehash string
-    runtimehash  *string
-}
-
-// findfuncbucket is an array of these structures.
-// Each bucket represents 4096 bytes of the text segment.
-// Each subbucket represents 256 bytes of the text segment.
-// To find a function given a pc, locate the bucket and subbucket for
-// that pc. Add together the idx and subbucket value to obtain a
-// function index. Then scan the functab array starting at that
-// index to find the target function.
-// This table uses 20 bytes for every 4096 bytes of code, or ~0.5% overhead.
-type findfuncbucket struct {
-    idx        uint32
-    _SUBBUCKETS [16]byte
-}
-
-
-type compilationUnit struct {
-    fileNames []string
-}
-
-// func name table format: 
-//   nameOff[0] -> namePartA namePartB namePartC \x00 
-//   nameOff[1] -> namePartA namePartB namePartC \x00
-//  ...
-func makeFuncnameTab(funcs []Func) (tab []byte, offs []int32) {
-    offs = make([]int32, len(funcs))
-    offset := 0
-
-    for i, f := range funcs {
-        offs[i] = int32(offset)
-
-        a, b, c := funcNameParts(f.Name)
-        tab = append(tab, a...)
-        tab = append(tab, b...)
-        tab = append(tab, c...)
-        tab = append(tab, 0)
-        offset += len(a) + len(b) + len(c) + 1
-    }
-
-    return
-}
-
-// CU table format:
-//  cuOffsets[0] -> filetabOffset[0] filetabOffset[1] ... filetabOffset[len(CUs[0].fileNames)-1]
-//  cuOffsets[1] -> filetabOffset[len(CUs[0].fileNames)] ... filetabOffset[len(CUs[0].fileNames) + len(CUs[1].fileNames)-1]
-//  ...
-//
-// file name table format:
-//  filetabOffset[0] -> CUs[0].fileNames[0] \x00
-//  ...
-//  filetabOffset[len(CUs[0]-1)] -> CUs[0].fileNames[len(CUs[0].fileNames)-1] \x00
-//  ...
-//  filetabOffset[SUM(CUs,fileNames)-1] -> CUs[len(CU)-1].fileNames[len(CUs[len(CU)-1].fileNames)-1] \x00
-func makeFilenametab(cus []compilationUnit) (cutab []uint32, filetab []byte, cuOffsets []uint32) {
-    cuOffsets = make([]uint32, len(cus))
-    cuOffset := 0
-    fileOffset := 0
-
-    for i, cu := range cus {
-        cuOffsets[i] = uint32(cuOffset)
-
-        for _, name := range cu.fileNames {
-            cutab = append(cutab, uint32(fileOffset))
-
-            fileOffset += len(name) + 1
-            filetab = append(filetab, name...)
-            filetab = append(filetab, 0)
-        }
-
-        cuOffset += len(cu.fileNames)
-    }
-
-    return
-}
-
-func writeFuncdata(out *[]byte, funcs []Func) (fstart int, funcdataOffs [][]uint32) {
-    fstart = len(*out)
-    *out = append(*out, byte(0))
-    offs := uint32(1)
-
-    funcdataOffs = make([][]uint32, len(funcs))
-    for i, f := range funcs {
-
-        var writer = func(fd encoding.BinaryMarshaler) {
-            var ab []byte
-            var err error
-            if fd != nil {
-                ab, err = fd.MarshalBinary()
-                if err != nil {
-                    panic(err)
-                }
-                funcdataOffs[i] = append(funcdataOffs[i], offs)
-            } else {
-                ab = []byte{0}
-                funcdataOffs[i] = append(funcdataOffs[i], _INVALID_FUNCDATA_OFFSET)
-            }
-            *out = append(*out, ab...)
-            offs += uint32(len(ab))
-        }
-
-        writer(f.ArgsPointerMaps)
-        writer(f.LocalsPointerMaps)
-        writer(f.StackObjects)
-        writer(f.InlTree)
-        writer(f.OpenCodedDeferInfo)
-        writer(f.ArgInfo)
-        writer(f.ArgLiveInfo)
-        writer(f.WrapInfo)
-    }
-    return 
-}
-
-func makeFtab(funcs []_func, lastFuncSize uint32) (ftab []funcTab, pclntabSize int64, startLocations []uint32) {
-    // Allocate space for the pc->func table. This structure consists of a pc offset
-    // and an offset to the func structure. After that, we have a single pc
-    // value that marks the end of the last function in the binary.
-    pclntabSize = int64(len(funcs)*2*int(_PtrSize) + int(_PtrSize))
-    startLocations = make([]uint32, len(funcs))
-    for i, f := range funcs {
-        pclntabSize = rnd(pclntabSize, int64(_PtrSize))
-        //writePCToFunc
-        startLocations[i] = uint32(pclntabSize)
-        pclntabSize += int64(uint8(_FUNC_SIZE) + f.nfuncdata*_PtrSize + uint8(f.npcdata)*4)
-    }
-    ftab = make([]funcTab, 0, len(funcs)+1)
-
-    // write a map of pc->func info offsets 
-    for i, f := range funcs {
-        ftab = append(ftab, funcTab{uintptr(f.entry), uintptr(startLocations[i])})
-    }
-
-    // Final entry of table is just end pc offset.
-    lastFunc := funcs[len(funcs)-1]
-    ftab = append(ftab, funcTab{lastFunc.entry + uintptr(lastFuncSize), 0})
-
-    return
-}
-
-// Pcln table format: [...]funcTab + [...]_Func
-func makePclntable(size int64, startLocations []uint32, funcs []_func, lastFuncSize uint32, pcdataOffs [][]uint32, funcdataAddr uintptr, funcdataOffs [][]uint32) (pclntab []byte) {
-    pclntab = make([]byte, size, size)
-
-    // write a map of pc->func info offsets 
-    offs := 0
-    for i, f := range funcs {
-        byteOrder.PutUint64(pclntab[offs:offs+8], uint64(f.entry))
-        byteOrder.PutUint64(pclntab[offs+8:offs+16], uint64(startLocations[i]))
-        offs += 16
-    }
-    // Final entry of table is just end pc offset.
-    lastFunc := funcs[len(funcs)-1]
-    byteOrder.PutUint64(pclntab[offs:offs+8], uint64(lastFunc.entry)+uint64(lastFuncSize))
-    offs += 8
-
-    // write func info table
-    for i, f := range funcs {
-        off := startLocations[i]
-
-        // write _func structure to pclntab
-        byteOrder.PutUint64(pclntab[off:off+8], uint64(f.entry))
-        off += 8
-        byteOrder.PutUint32(pclntab[off:off+4], uint32(f.nameOff))
-        off += 4
-        byteOrder.PutUint32(pclntab[off:off+4], uint32(f.args))
-        off += 4
-        byteOrder.PutUint32(pclntab[off:off+4], uint32(f.deferreturn))
-        off += 4
-        byteOrder.PutUint32(pclntab[off:off+4], uint32(f.pcsp))
-        off += 4
-        byteOrder.PutUint32(pclntab[off:off+4], uint32(f.pcfile))
-        off += 4
-        byteOrder.PutUint32(pclntab[off:off+4], uint32(f.pcln))
-        off += 4
-        byteOrder.PutUint32(pclntab[off:off+4], uint32(f.npcdata))
-        off += 4
-        byteOrder.PutUint32(pclntab[off:off+4], uint32(f.cuOffset))
-        off += 4
-        pclntab[off] = f.funcID
-        // NOTICE: _[2]byte alignment
-        off += 3
-        pclntab[off] = f.nfuncdata
-        off += 1
-
-        // NOTICE: _func.pcdata always starts from PcUnsafePoint, which is index 3
-        for j := 3; j < len(pcdataOffs[i]); j++ {
-            byteOrder.PutUint32(pclntab[off:off+4], uint32(pcdataOffs[i][j]))
-            off += 4
-        }
-
-        off = uint32(rnd(int64(off), int64(_PtrSize)))
-
-        // funcdata refs as offsets from gofunc
-        for _, funcdata := range funcdataOffs[i] {
-            if funcdata == _INVALID_FUNCDATA_OFFSET {
-                byteOrder.PutUint64(pclntab[off:off+8], 0)
-            } else {
-                byteOrder.PutUint64(pclntab[off:off+8], uint64(funcdataAddr)+uint64(funcdata))
-            }
-            off += 8
-        }
-    }
-
-    return
-}
-
-// findfunc table used to map pc to belonging func, 
-// returns the index in the func table.
-//
-// All text section are divided into buckets sized _BUCKETSIZE(4K):
-//   every bucket is divided into _SUBBUCKETS sized _SUB_BUCKETSIZE(64),
-//   and it has a base idx to plus the offset stored in jth subbucket.
-// see findfunc() in runtime/symtab.go
-func writeFindfunctab(out *[]byte, ftab []funcTab) (start int) {
-    start = len(*out)
-
-    max := ftab[len(ftab)-1].entry
-    min := ftab[0].entry
-    nbuckets := (max - min + _BUCKETSIZE - 1) / _BUCKETSIZE
-    n := (max - min + _SUB_BUCKETSIZE - 1) / _SUB_BUCKETSIZE
-
-    tab := make([]findfuncbucket, 0, nbuckets)
-    var s, e = 0, 0
-    for i := 0; i<int(nbuckets); i++ {
-        var pc = min + uintptr((i+1)*_BUCKETSIZE)
-        // find the end func of the bucket
-        for ; e < len(ftab)-1 && ftab[e+1].entry <= pc; e++ {}
-        // store the start func of the bucket
-        var fb = findfuncbucket{idx: uint32(s)}
-
-        for j := 0; j<_SUBBUCKETS && (i*_SUBBUCKETS+j)<int(n); j++ {
-            pc = min + uintptr(i*_BUCKETSIZE) + uintptr((j+1)*_SUB_BUCKETSIZE)
-            var ss = s
-            // find the end func of the subbucket
-            for ; ss < len(ftab)-1 && ftab[ss+1].entry <= pc; ss++ {}
-            // store the start func of the subbucket
-            fb._SUBBUCKETS[j] = byte(uint32(s) - fb.idx)
-            s = ss
-        }
-        s = e
-        tab = append(tab, fb)
-    }
-
-    // write findfuncbucket
-    if len(tab) > 0 {
-        size := int(unsafe.Sizeof(findfuncbucket{}))*len(tab)
-        *out = append(*out, rt.BytesFrom(unsafe.Pointer(&tab[0]), size, size)...)
-    }
-    return 
-}
-
-func makeModuledata(name string, filenames []string, funcs []Func, text []byte) (mod *moduledata) {
-    mod = new(moduledata)
-    mod.modulename = name
-
-    // make filename table
-    cu := make([]string, 0, len(filenames))
-    for _, f := range filenames {
-        cu = append(cu, f)
-    }
-    cutab, filetab, cuOffs := makeFilenametab([]compilationUnit{{cu}})
-    mod.cutab = cutab
-    mod.filetab = filetab
-
-    // make funcname table
-    funcnametab, nameOffs := makeFuncnameTab(funcs)
-    mod.funcnametab = funcnametab
-
-    // mmap() text and funcdata segements
-    p := os.Getpagesize()
-    size := int(rnd(int64(len(text)), int64(p)))
-    addr := mmap(size)
-    // copy the machine code
-    s := rt.BytesFrom(unsafe.Pointer(addr), len(text), size)
-    copy(s, text)
-    // make it executable
-    mprotect(addr, size)
-
-    // make pcdata table
-    // NOTICE: _func only use offset to index pcdata, thus no need mmap() pcdata 
-    pctab, pcdataOffs, _funcs := makePctab(funcs, addr, cuOffs, nameOffs)
-    mod.pctab = pctab
-
-    // write func data
-    // NOTICE: _func use mod.gofunc+offset to directly point funcdata, thus need cache funcdata
-    // TODO: estimate accurate capacity
-    cache := make([]byte, 0, len(funcs)*int(_PtrSize)) 
-    fstart, funcdataOffs := writeFuncdata(&cache, funcs)
-
-    // make pc->func (binary search) func table
-    lastFuncsize := funcs[len(funcs)-1].TextSize
-    ftab, pclntSize, startLocations := makeFtab(_funcs, lastFuncsize)
-    mod.ftab = ftab
-
-    // write pc->func (modmap) findfunc table
-    ffstart := writeFindfunctab(&cache, ftab)
-
-    // cache funcdata and findfuncbucket
-    moduleCache.Lock()
-    moduleCache.m[mod] = cache
-    moduleCache.Unlock()
-    mod.findfunctab = uintptr(rt.IndexByte(cache, ffstart))
-    funcdataAddr := uintptr(rt.IndexByte(cache, fstart))
-
-    // make pclnt table
-    pclntab := makePclntable(pclntSize, startLocations, _funcs, lastFuncsize, pcdataOffs, funcdataAddr, funcdataOffs)
-    mod.pclntable = pclntab
-
-    // assign addresses
-    mod.text = addr
-    mod.etext = addr + uintptr(size)
-    mod.minpc = addr
-    mod.maxpc = addr + uintptr(len(text))
-
-    // make pc header
-    mod.pcHeader = &pcHeader {
-        magic   : _Magic,
-        minLC   : _MinLC,
-        ptrSize : _PtrSize,
-        nfunc   : len(funcs),
-        nfiles: uint(len(cu)),
-        funcnameOffset: getOffsetOf(moduledata{}, "funcnametab"),
-        cuOffset: getOffsetOf(moduledata{}, "cutab"),
-        filetabOffset: getOffsetOf(moduledata{}, "filetab"),
-        pctabOffset: getOffsetOf(moduledata{}, "pctab"),
-        pclnOffset: getOffsetOf(moduledata{}, "pclntable"),
-    }
-
-    // sepecial case: gcdata and gcbss must by non-empty
-    mod.gcdata = uintptr(unsafe.Pointer(&emptyByte))
-    mod.gcbss = uintptr(unsafe.Pointer(&emptyByte))
-
-    return
-}
-
-// makePctab generates pcdelta->valuedelta tables for functions,
-// and returns the table and the entry offset of every kind pcdata in the table.
-func makePctab(funcs []Func, addr uintptr, cuOffset []uint32, nameOffset []int32) (pctab []byte, pcdataOffs [][]uint32, _funcs []_func) {
-    _funcs = make([]_func, len(funcs))
-
-    // Pctab offsets of 0 are considered invalid in the runtime. We respect
-    // that by just padding a single byte at the beginning of runtime.pctab,
-    // that way no real offsets can be zero.
-    pctab = make([]byte, 1, 12*len(funcs)+1)
-    pcdataOffs = make([][]uint32, len(funcs))
-
-    for i, f := range funcs {
-        _f := &_funcs[i]
-
-        var writer = func(pc *Pcdata) {
-            var ab []byte
-            var err error
-            if pc != nil {
-                ab, err = pc.MarshalBinary()
-                if err != nil {
-                    panic(err)
-                }
-                pcdataOffs[i] = append(pcdataOffs[i], uint32(len(pctab)))
-            } else {
-                ab = []byte{0}
-                pcdataOffs[i] = append(pcdataOffs[i], _PCDATA_INVALID_OFFSET)
-            }
-            pctab = append(pctab, ab...)
-        }
-
-        if f.Pcsp != nil {
-            _f.pcsp = uint32(len(pctab))
-        }
-        writer(f.Pcsp)
-        if f.Pcfile != nil {
-            _f.pcfile = uint32(len(pctab))
-        }
-        writer(f.Pcfile)
-        if f.Pcline != nil {
-            _f.pcln = uint32(len(pctab))
-        }
-        writer(f.Pcline)
-        writer(f.PcUnsafePoint)
-        writer(f.PcStackMapIndex)
-        writer(f.PcInlTreeIndex)
-        writer(f.PcArgLiveIndex)
-        
-        _f.entry = addr + uintptr(f.EntryOff)
-        _f.nameOff = nameOffset[i]
-        _f.args = f.ArgsSize
-        _f.deferreturn = f.DeferReturn
-        // NOTICE: _func.pcdata is always as [PCDATA_UnsafePoint(0) : PCDATA_ArgLiveIndex(3)]
-        _f.npcdata = uint32(_N_PCDATA)
-        _f.cuOffset = cuOffset[i]
-        _f.funcID = f.ID
-        _f.nfuncdata = uint8(_N_FUNCDATA)
-    }
-
-    return
-}
-
-func registerFunction(name string, pc uintptr, textSize uintptr, fp int, args int, size uintptr, argptrs uintptr, localptrs uintptr) {} 

vendor/github.com/bytedance/sonic/loader/funcdata_go116.go

@@ -20,9 +20,9 @@
 package loader
 
 import (
-   `encoding`
    `os`
    `unsafe`
+   `sort`
 
    `github.com/bytedance/sonic/internal/rt`
 )
@@ -171,99 +171,7 @@ type compilationUnit struct {
     fileNames []string
 }
 
-// func name table format: 
-//   nameOff[0] -> namePartA namePartB namePartC \x00 
-//   nameOff[1] -> namePartA namePartB namePartC \x00
-//  ...
-func makeFuncnameTab(funcs []Func) (tab []byte, offs []int32) {
-    offs = make([]int32, len(funcs))
-    offset := 0
-
-    for i, f := range funcs {
-        offs[i] = int32(offset)
-
-        a, b, c := funcNameParts(f.Name)
-        tab = append(tab, a...)
-        tab = append(tab, b...)
-        tab = append(tab, c...)
-        tab = append(tab, 0)
-        offset += len(a) + len(b) + len(c) + 1
-    }
-
-    return
-}
-
-// CU table format:
-//  cuOffsets[0] -> filetabOffset[0] filetabOffset[1] ... filetabOffset[len(CUs[0].fileNames)-1]
-//  cuOffsets[1] -> filetabOffset[len(CUs[0].fileNames)] ... filetabOffset[len(CUs[0].fileNames) + len(CUs[1].fileNames)-1]
-//  ...
-//
-// file name table format:
-//  filetabOffset[0] -> CUs[0].fileNames[0] \x00
-//  ...
-//  filetabOffset[len(CUs[0]-1)] -> CUs[0].fileNames[len(CUs[0].fileNames)-1] \x00
-//  ...
-//  filetabOffset[SUM(CUs,fileNames)-1] -> CUs[len(CU)-1].fileNames[len(CUs[len(CU)-1].fileNames)-1] \x00
-func makeFilenametab(cus []compilationUnit) (cutab []uint32, filetab []byte, cuOffsets []uint32) {
-    cuOffsets = make([]uint32, len(cus))
-    cuOffset := 0
-    fileOffset := 0
-
-    for i, cu := range cus {
-        cuOffsets[i] = uint32(cuOffset)
-
-        for _, name := range cu.fileNames {
-            cutab = append(cutab, uint32(fileOffset))
-
-            fileOffset += len(name) + 1
-            filetab = append(filetab, name...)
-            filetab = append(filetab, 0)
-        }
-
-        cuOffset += len(cu.fileNames)
-    }
-
-    return
-}
-
-func writeFuncdata(out *[]byte, funcs []Func) (fstart int, funcdataOffs [][]uint32) {
-    fstart = len(*out)
-    *out = append(*out, byte(0))
-    offs := uint32(1)
-
-    funcdataOffs = make([][]uint32, len(funcs))
-    for i, f := range funcs {
-
-        var writer = func(fd encoding.BinaryMarshaler) {
-            var ab []byte
-            var err error
-            if fd != nil {
-                ab, err = fd.MarshalBinary()
-                if err != nil {
-                    panic(err)
-                }
-                funcdataOffs[i] = append(funcdataOffs[i], offs)
-            } else {
-                ab = []byte{0}
-                funcdataOffs[i] = append(funcdataOffs[i], _INVALID_FUNCDATA_OFFSET)
-            }
-            *out = append(*out, ab...)
-            offs += uint32(len(ab))
-        }
-
-        writer(f.ArgsPointerMaps)
-        writer(f.LocalsPointerMaps)
-        writer(f.StackObjects)
-        writer(f.InlTree)
-        writer(f.OpenCodedDeferInfo)
-        writer(f.ArgInfo)
-        writer(f.ArgLiveInfo)
-        writer(f.WrapInfo)
-    }
-    return 
-}
-
-func makeFtab(funcs []_func, lastFuncSize uint32) (ftab []funcTab, pclntabSize int64, startLocations []uint32) {
+func makeFtab(funcs []_func, maxpc uintptr) (ftab []funcTab, pclntabSize int64, startLocations []uint32) {
     // Allocate space for the pc->func table. This structure consists of a pc offset
     // and an offset to the func structure. After that, we have a single pc
     // value that marks the end of the last function in the binary.
@@ -283,14 +191,13 @@ func makeFtab(funcs []_func, lastFuncSize uint32) (ftab []funcTab, pclntabSize i
     }
 
     // Final entry of table is just end pc offset.
-    lastFunc := funcs[len(funcs)-1]
-    ftab = append(ftab, funcTab{lastFunc.entry + uintptr(lastFuncSize), 0})
+    ftab = append(ftab, funcTab{maxpc, 0})
 
     return
 }
 
 // Pcln table format: [...]funcTab + [...]_Func
-func makePclntable(size int64, startLocations []uint32, funcs []_func, lastFuncSize uint32, pcdataOffs [][]uint32, funcdataAddr uintptr, funcdataOffs [][]uint32) (pclntab []byte) {
+func makePclntable(size int64, startLocations []uint32, funcs []_func, maxpc uintptr, pcdataOffs [][]uint32, funcdataAddr uintptr, funcdataOffs [][]uint32) (pclntab []byte) {
     pclntab = make([]byte, size, size)
 
     // write a map of pc->func info offsets 
@@ -301,8 +208,7 @@ func makePclntable(size int64, startLocations []uint32, funcs []_func, lastFuncS
         offs += 16
     }
     // Final entry of table is just end pc offset.
-    lastFunc := funcs[len(funcs)-1]
-    byteOrder.PutUint64(pclntab[offs:offs+8], uint64(lastFunc.entry)+uint64(lastFuncSize))
+    byteOrder.PutUint64(pclntab[offs:offs+8], uint64(maxpc))
     offs += 8
 
     // write func info table
@@ -374,21 +280,22 @@ func writeFindfunctab(out *[]byte, ftab []funcTab) (start int) {
     tab := make([]findfuncbucket, 0, nbuckets)
     var s, e = 0, 0
     for i := 0; i<int(nbuckets); i++ {
-        var pc = min + uintptr((i+1)*_BUCKETSIZE)
-        // find the end func of the bucket
-        for ; e < len(ftab)-1 && ftab[e+1].entry <= pc; e++ {}
         // store the start func of the bucket
         var fb = findfuncbucket{idx: uint32(s)}
 
+        // find the last e-th func of the bucket
+        var pc = min + uintptr((i+1)*_BUCKETSIZE)
+        for ; e < len(ftab)-1 && ftab[e+1].entry <= pc; e++ {}
+        
         for j := 0; j<_SUBBUCKETS && (i*_SUBBUCKETS+j)<int(n); j++ {
-            pc = min + uintptr(i*_BUCKETSIZE) + uintptr((j+1)*_SUB_BUCKETSIZE)
-            var ss = s
-            // find the end func of the subbucket
-            for ; ss < len(ftab)-1 && ftab[ss+1].entry <= pc; ss++ {}
             // store the start func of the subbucket
             fb._SUBBUCKETS[j] = byte(uint32(s) - fb.idx)
-            s = ss
+            
+            // find the s-th end func of the subbucket
+            pc = min + uintptr(i*_BUCKETSIZE) + uintptr((j+1)*_SUB_BUCKETSIZE)
+            for ; s < len(ftab)-1 && ftab[s+1].entry <= pc; s++ {}            
         }
+
         s = e
         tab = append(tab, fb)
     }
@@ -401,15 +308,20 @@ func writeFindfunctab(out *[]byte, ftab []funcTab) (start int) {
     return 
 }
 
-func makeModuledata(name string, filenames []string, funcs []Func, text []byte) (mod *moduledata) {
+func makeModuledata(name string, filenames []string, funcsp *[]Func, text []byte) (mod *moduledata) {
     mod = new(moduledata)
     mod.modulename = name
 
+    // sort funcs by entry
+    funcs := *funcsp
+    sort.Slice(funcs, func(i, j int) bool {
+        return funcs[i].EntryOff < funcs[j].EntryOff
+    })
+    *funcsp = funcs
+
     // make filename table
     cu := make([]string, 0, len(filenames))
-    for _, f := range filenames {
-        cu = append(cu, f)
-    }
+    cu = append(cu, filenames...)
     cutab, filetab, cuOffs := makeFilenametab([]compilationUnit{{cu}})
     mod.cutab = cutab
     mod.filetab = filetab
@@ -428,9 +340,16 @@ func makeModuledata(name string, filenames []string, funcs []Func, text []byte)
     // make it executable
     mprotect(addr, size)
 
+    // assign addresses
+    mod.text = addr
+    mod.etext = addr + uintptr(size)
+    mod.minpc = addr
+    mod.maxpc = addr + uintptr(len(text))
+
     // make pcdata table
     // NOTICE: _func only use offset to index pcdata, thus no need mmap() pcdata 
-    pctab, pcdataOffs, _funcs := makePctab(funcs, addr, cuOffs, nameOffs)
+    cuOff := cuOffs[0]
+    pctab, pcdataOffs, _funcs := makePctab(funcs, addr, cuOff, nameOffs)
     mod.pctab = pctab
 
     // write func data
@@ -440,8 +359,7 @@ func makeModuledata(name string, filenames []string, funcs []Func, text []byte)
     fstart, funcdataOffs := writeFuncdata(&cache, funcs)
 
     // make pc->func (binary search) func table
-    lastFuncsize := funcs[len(funcs)-1].TextSize
-    ftab, pclntSize, startLocations := makeFtab(_funcs, lastFuncsize)
+    ftab, pclntSize, startLocations := makeFtab(_funcs, mod.maxpc)
     mod.ftab = ftab
 
     // write pc->func (modmap) findfunc table
@@ -455,15 +373,9 @@ func makeModuledata(name string, filenames []string, funcs []Func, text []byte)
     funcdataAddr := uintptr(rt.IndexByte(cache, fstart))
 
     // make pclnt table
-    pclntab := makePclntable(pclntSize, startLocations, _funcs, lastFuncsize, pcdataOffs, funcdataAddr, funcdataOffs)
+    pclntab := makePclntable(pclntSize, startLocations, _funcs, mod.maxpc, pcdataOffs, funcdataAddr, funcdataOffs)
     mod.pclntable = pclntab
 
-    // assign addresses
-    mod.text = addr
-    mod.etext = addr + uintptr(size)
-    mod.minpc = addr
-    mod.maxpc = addr + uintptr(len(text))
-
     // make pc header
     mod.pcHeader = &pcHeader {
         magic   : _Magic,
@@ -487,7 +399,7 @@ func makeModuledata(name string, filenames []string, funcs []Func, text []byte)
 
 // makePctab generates pcdelta->valuedelta tables for functions,
 // and returns the table and the entry offset of every kind pcdata in the table.
-func makePctab(funcs []Func, addr uintptr, cuOffset []uint32, nameOffset []int32) (pctab []byte, pcdataOffs [][]uint32, _funcs []_func) {
+func makePctab(funcs []Func, addr uintptr, cuOffset uint32, nameOffset []int32) (pctab []byte, pcdataOffs [][]uint32, _funcs []_func) {
     _funcs = make([]_func, len(funcs))
 
     // Pctab offsets of 0 are considered invalid in the runtime. We respect
@@ -538,7 +450,7 @@ func makePctab(funcs []Func, addr uintptr, cuOffset []uint32, nameOffset []int32
         _f.deferreturn = f.DeferReturn
         // NOTICE: _func.pcdata is always as [PCDATA_UnsafePoint(0) : PCDATA_ArgLiveIndex(3)]
         _f.npcdata = uint32(_N_PCDATA)
-        _f.cuOffset = cuOffset[i]
+        _f.cuOffset = cuOffset
         _f.funcID = f.ID
         _f.nfuncdata = uint8(_N_FUNCDATA)
     }

vendor/github.com/bytedance/sonic/loader/funcdata_go118.go

@@ -1,4 +1,5 @@
 // go:build go1.18 && !go1.20
+//go:build go1.18 && !go1.20
 // +build go1.18,!go1.20
 
 /*
@@ -20,10 +21,6 @@
 package loader
 
 import (
-    `encoding`
-    `os`
-    `unsafe`
-
     `github.com/bytedance/sonic/internal/rt`
 )
 
@@ -31,21 +28,6 @@ const (
     _Magic uint32 = 0xfffffff0
 )
 
-type pcHeader struct {
-    magic          uint32  // 0xFFFFFFF0
-    pad1, pad2     uint8   // 0,0
-    minLC          uint8   // min instruction size
-    ptrSize        uint8   // size of a ptr in bytes
-    nfunc          int     // number of functions in the module
-    nfiles         uint    // number of entries in the file tab
-    textStart      uintptr // base for function entry PC offsets in this module, equal to moduledata.text
-    funcnameOffset uintptr // offset to the funcnametab variable from pcHeader
-    cuOffset       uintptr // offset to the cutab variable from pcHeader
-    filetabOffset  uintptr // offset to the filetab variable from pcHeader
-    pctabOffset    uintptr // offset to the pctab variable from pcHeader
-    pclnOffset     uintptr // offset to the pclntab variable from pcHeader
-}
-
 type moduledata struct {
     pcHeader     *pcHeader
     funcnametab  []byte
@@ -129,413 +111,3 @@ type _func struct {
     //
     // funcdata [nfuncdata]uint32
 }
-
-type funcTab struct {
-    entry   uint32
-    funcoff uint32
-}
-
-type bitVector struct {
-    n        int32 // # of bits
-    bytedata *uint8
-}
-
-type ptabEntry struct {
-    name int32
-    typ  int32
-}
-
-type textSection struct {
-    vaddr    uintptr // prelinked section vaddr
-    end      uintptr // vaddr + section length
-    baseaddr uintptr // relocated section address
-}
-
-type modulehash struct {
-    modulename   string
-    linktimehash string
-    runtimehash  *string
-}
-
-// findfuncbucket is an array of these structures.
-// Each bucket represents 4096 bytes of the text segment.
-// Each subbucket represents 256 bytes of the text segment.
-// To find a function given a pc, locate the bucket and subbucket for
-// that pc. Add together the idx and subbucket value to obtain a
-// function index. Then scan the functab array starting at that
-// index to find the target function.
-// This table uses 20 bytes for every 4096 bytes of code, or ~0.5% overhead.
-type findfuncbucket struct {
-    idx        uint32
-    _SUBBUCKETS [16]byte
-}
-
-// func name table format: 
-//   nameOff[0] -> namePartA namePartB namePartC \x00 
-//   nameOff[1] -> namePartA namePartB namePartC \x00
-//  ...
-func makeFuncnameTab(funcs []Func) (tab []byte, offs []int32) {
-    offs = make([]int32, len(funcs))
-    offset := 0
-
-    for i, f := range funcs {
-        offs[i] = int32(offset)
-
-        a, b, c := funcNameParts(f.Name)
-        tab = append(tab, a...)
-        tab = append(tab, b...)
-        tab = append(tab, c...)
-        tab = append(tab, 0)
-        offset += len(a) + len(b) + len(c) + 1
-    }
-
-    return
-}
-
-type compilationUnit struct {
-    fileNames []string
-}
-
-// CU table format:
-//  cuOffsets[0] -> filetabOffset[0] filetabOffset[1] ... filetabOffset[len(CUs[0].fileNames)-1]
-//  cuOffsets[1] -> filetabOffset[len(CUs[0].fileNames)] ... filetabOffset[len(CUs[0].fileNames) + len(CUs[1].fileNames)-1]
-//  ...
-//
-// file name table format:
-//  filetabOffset[0] -> CUs[0].fileNames[0] \x00
-//  ...
-//  filetabOffset[len(CUs[0]-1)] -> CUs[0].fileNames[len(CUs[0].fileNames)-1] \x00
-//  ...
-//  filetabOffset[SUM(CUs,fileNames)-1] -> CUs[len(CU)-1].fileNames[len(CUs[len(CU)-1].fileNames)-1] \x00
-func makeFilenametab(cus []compilationUnit) (cutab []uint32, filetab []byte, cuOffsets []uint32) {
-    cuOffsets = make([]uint32, len(cus))
-    cuOffset := 0
-    fileOffset := 0
-
-    for i, cu := range cus {
-        cuOffsets[i] = uint32(cuOffset)
-
-        for _, name := range cu.fileNames {
-            cutab = append(cutab, uint32(fileOffset))
-
-            fileOffset += len(name) + 1
-            filetab = append(filetab, name...)
-            filetab = append(filetab, 0)
-        }
-
-        cuOffset += len(cu.fileNames)
-    }
-
-    return
-}
-
-func writeFuncdata(out *[]byte, funcs []Func) (fstart int, funcdataOffs [][]uint32) {
-    fstart = len(*out)
-    *out = append(*out, byte(0))
-    offs := uint32(1)
-
-    funcdataOffs = make([][]uint32, len(funcs))
-    for i, f := range funcs {
-
-        var writer = func(fd encoding.BinaryMarshaler) {
-            var ab []byte
-            var err error
-            if fd != nil {
-                ab, err = fd.MarshalBinary()
-                if err != nil {
-                    panic(err)
-                }
-                funcdataOffs[i] = append(funcdataOffs[i], offs)
-            } else {
-                ab = []byte{0}
-                funcdataOffs[i] = append(funcdataOffs[i], _INVALID_FUNCDATA_OFFSET)
-            }
-            *out = append(*out, ab...)
-            offs += uint32(len(ab))
-        }
-
-        writer(f.ArgsPointerMaps)
-        writer(f.LocalsPointerMaps)
-        writer(f.StackObjects)
-        writer(f.InlTree)
-        writer(f.OpenCodedDeferInfo)
-        writer(f.ArgInfo)
-        writer(f.ArgLiveInfo)
-        writer(f.WrapInfo)
-    }
-    return 
-}
-
-func makeFtab(funcs []_func, lastFuncSize uint32) (ftab []funcTab) {
-    // Allocate space for the pc->func table. This structure consists of a pc offset
-    // and an offset to the func structure. After that, we have a single pc
-    // value that marks the end of the last function in the binary.
-    var size int64 = int64(len(funcs)*2*4 + 4)
-    var startLocations = make([]uint32, len(funcs))
-    for i, f := range funcs {
-        size = rnd(size, int64(_PtrSize))
-        //writePCToFunc
-        startLocations[i] = uint32(size)
-        size += int64(uint8(_FUNC_SIZE)+f.nfuncdata*4+uint8(f.npcdata)*4)
-    }
-
-    ftab = make([]funcTab, 0, len(funcs)+1)
-
-    // write a map of pc->func info offsets 
-    for i, f := range funcs {
-        ftab = append(ftab, funcTab{uint32(f.entryOff), uint32(startLocations[i])})
-    }
-
-    // Final entry of table is just end pc offset.
-    lastFunc := funcs[len(funcs)-1]
-    ftab = append(ftab, funcTab{uint32(lastFunc.entryOff + lastFuncSize), 0})
-
-    return
-}
-
-// Pcln table format: [...]funcTab + [...]_Func
-func makePclntable(funcs []_func, lastFuncSize uint32, pcdataOffs [][]uint32, funcdataOffs [][]uint32) (pclntab []byte) {
-    // Allocate space for the pc->func table. This structure consists of a pc offset
-    // and an offset to the func structure. After that, we have a single pc
-    // value that marks the end of the last function in the binary.
-    var size int64 = int64(len(funcs)*2*4 + 4)
-    var startLocations = make([]uint32, len(funcs))
-    for i := range funcs {
-        size = rnd(size, int64(_PtrSize))
-        //writePCToFunc
-        startLocations[i] = uint32(size)
-        size += int64(int(_FUNC_SIZE)+len(funcdataOffs[i])*4+len(pcdataOffs[i])*4)
-    }
-
-    pclntab = make([]byte, size, size)
-
-    // write a map of pc->func info offsets 
-    offs := 0
-    for i, f := range funcs {
-        byteOrder.PutUint32(pclntab[offs:offs+4], uint32(f.entryOff))
-        byteOrder.PutUint32(pclntab[offs+4:offs+8], uint32(startLocations[i]))
-        offs += 8
-    }
-    // Final entry of table is just end pc offset.
-    lastFunc := funcs[len(funcs)-1]
-    byteOrder.PutUint32(pclntab[offs:offs+4], uint32(lastFunc.entryOff+lastFuncSize))
-
-    // write func info table
-    for i, f := range funcs {
-        off := startLocations[i]
-
-        // write _func structure to pclntab
-        fb := rt.BytesFrom(unsafe.Pointer(&f), int(_FUNC_SIZE), int(_FUNC_SIZE))
-        copy(pclntab[off:off+uint32(_FUNC_SIZE)], fb)
-        off += uint32(_FUNC_SIZE)
-
-        // NOTICE: _func.pcdata always starts from PcUnsafePoint, which is index 3
-        for j := 3; j < len(pcdataOffs[i]); j++ {
-            byteOrder.PutUint32(pclntab[off:off+4], uint32(pcdataOffs[i][j]))
-            off += 4
-        }
-
-        // funcdata refs as offsets from gofunc
-        for _, funcdata := range funcdataOffs[i] {
-            byteOrder.PutUint32(pclntab[off:off+4], uint32(funcdata))
-            off += 4
-        }
-
-    }
-
-    return
-}
-
-// findfunc table used to map pc to belonging func, 
-// returns the index in the func table.
-//
-// All text section are divided into buckets sized _BUCKETSIZE(4K):
-//   every bucket is divided into _SUBBUCKETS sized _SUB_BUCKETSIZE(64),
-//   and it has a base idx to plus the offset stored in jth subbucket.
-// see findfunc() in runtime/symtab.go
-func writeFindfunctab(out *[]byte, ftab []funcTab) (start int) {
-    start = len(*out)
-
-    max := ftab[len(ftab)-1].entry
-    min := ftab[0].entry
-    nbuckets := (max - min + _BUCKETSIZE - 1) / _BUCKETSIZE
-    n := (max - min + _SUB_BUCKETSIZE - 1) / _SUB_BUCKETSIZE
-
-    tab := make([]findfuncbucket, 0, nbuckets)
-    var s, e = 0, 0
-    for i := 0; i<int(nbuckets); i++ {
-        var pc = min + uint32((i+1)*_BUCKETSIZE)
-        // find the end func of the bucket
-        for ; e < len(ftab)-1 && ftab[e+1].entry <= pc; e++ {}
-        // store the start func of the bucket
-        var fb = findfuncbucket{idx: uint32(s)}
-
-        for j := 0; j<_SUBBUCKETS && (i*_SUBBUCKETS+j)<int(n); j++ {
-            pc = min + uint32(i*_BUCKETSIZE) + uint32((j+1)*_SUB_BUCKETSIZE)
-            var ss = s
-            // find the end func of the subbucket
-            for ; ss < len(ftab)-1 && ftab[ss+1].entry <= pc; ss++ {}
-            // store the start func of the subbucket
-            fb._SUBBUCKETS[j] = byte(uint32(s) - fb.idx)
-            s = ss
-        }
-        s = e
-        tab = append(tab, fb)
-    }
-
-    // write findfuncbucket
-    if len(tab) > 0 {
-        size := int(unsafe.Sizeof(findfuncbucket{}))*len(tab)
-        *out = append(*out, rt.BytesFrom(unsafe.Pointer(&tab[0]), size, size)...)
-    }
-    return 
-}
-
-func makeModuledata(name string, filenames []string, funcs []Func, text []byte) (mod *moduledata) {
-    mod = new(moduledata)
-    mod.modulename = name
-
-    // make filename table
-    cu := make([]string, 0, len(filenames))
-    for _, f := range filenames {
-        cu = append(cu, f)
-    }
-    cutab, filetab, cuOffs := makeFilenametab([]compilationUnit{{cu}})
-    mod.cutab = cutab
-    mod.filetab = filetab
-
-    // make funcname table
-    funcnametab, nameOffs := makeFuncnameTab(funcs)
-    mod.funcnametab = funcnametab
-
-    // make pcdata table
-    // NOTICE: _func only use offset to index pcdata, thus no need mmap() pcdata 
-    pctab, pcdataOffs, _funcs := makePctab(funcs, cuOffs, nameOffs)
-    mod.pctab = pctab
-
-    // write func data
-    // NOTICE: _func use mod.gofunc+offset to directly point funcdata, thus need cache funcdata
-    // TODO: estimate accurate capacity
-    cache := make([]byte, 0, len(funcs)*int(_PtrSize)) 
-    fstart, funcdataOffs := writeFuncdata(&cache, funcs)
-
-    // make pc->func (binary search) func table
-    lastFuncsize := funcs[len(funcs)-1].TextSize
-    ftab := makeFtab(_funcs, lastFuncsize)
-    mod.ftab = ftab
-
-    // write pc->func (modmap) findfunc table
-    ffstart := writeFindfunctab(&cache, ftab)
-
-    // make pclnt table
-    pclntab := makePclntable(_funcs, lastFuncsize, pcdataOffs, funcdataOffs)
-    mod.pclntable = pclntab
-
-    // mmap() text and funcdata segements
-    p := os.Getpagesize()
-    size := int(rnd(int64(len(text)), int64(p)))
-    addr := mmap(size)
-    // copy the machine code
-    s := rt.BytesFrom(unsafe.Pointer(addr), len(text), size)
-    copy(s, text)
-    // make it executable
-    mprotect(addr, size)
-
-    // assign addresses
-    mod.text = addr
-    mod.etext = addr + uintptr(size)
-    mod.minpc = addr
-    mod.maxpc = addr + uintptr(len(text))
-
-    // cache funcdata and findfuncbucket
-    moduleCache.Lock()
-    moduleCache.m[mod] = cache
-    moduleCache.Unlock()
-    mod.gofunc = uintptr(unsafe.Pointer(&cache[fstart]))
-    mod.findfunctab = uintptr(unsafe.Pointer(&cache[ffstart]))
-
-    // make pc header
-    mod.pcHeader = &pcHeader {
-        magic   : _Magic,
-        minLC   : _MinLC,
-        ptrSize : _PtrSize,
-        nfunc   : len(funcs),
-        nfiles: uint(len(cu)),
-        textStart: mod.text,
-        funcnameOffset: getOffsetOf(moduledata{}, "funcnametab"),
-        cuOffset: getOffsetOf(moduledata{}, "cutab"),
-        filetabOffset: getOffsetOf(moduledata{}, "filetab"),
-        pctabOffset: getOffsetOf(moduledata{}, "pctab"),
-        pclnOffset: getOffsetOf(moduledata{}, "pclntable"),
-    }
-
-    // sepecial case: gcdata and gcbss must by non-empty
-    mod.gcdata = uintptr(unsafe.Pointer(&emptyByte))
-    mod.gcbss = uintptr(unsafe.Pointer(&emptyByte))
-
-    return
-}
-
-// makePctab generates pcdelta->valuedelta tables for functions,
-// and returns the table and the entry offset of every kind pcdata in the table.
-func makePctab(funcs []Func, cuOffset []uint32, nameOffset []int32) (pctab []byte, pcdataOffs [][]uint32, _funcs []_func) {
-    _funcs = make([]_func, len(funcs))
-
-    // Pctab offsets of 0 are considered invalid in the runtime. We respect
-    // that by just padding a single byte at the beginning of runtime.pctab,
-    // that way no real offsets can be zero.
-    pctab = make([]byte, 1, 12*len(funcs)+1)
-    pcdataOffs = make([][]uint32, len(funcs))
-
-    for i, f := range funcs {
-        _f := &_funcs[i]
-
-        var writer = func(pc *Pcdata) {
-            var ab []byte
-            var err error
-            if pc != nil {
-                ab, err = pc.MarshalBinary()
-                if err != nil {
-                    panic(err)
-                }
-                pcdataOffs[i] = append(pcdataOffs[i], uint32(len(pctab)))
-            } else {
-                ab = []byte{0}
-                pcdataOffs[i] = append(pcdataOffs[i], _PCDATA_INVALID_OFFSET)
-            }
-            pctab = append(pctab, ab...)
-        }
-
-        if f.Pcsp != nil {
-            _f.pcsp = uint32(len(pctab))
-        }
-        writer(f.Pcsp)
-        if f.Pcfile != nil {
-            _f.pcfile = uint32(len(pctab))
-        }
-        writer(f.Pcfile)
-        if f.Pcline != nil {
-            _f.pcln = uint32(len(pctab))
-        }
-        writer(f.Pcline)
-        writer(f.PcUnsafePoint)
-        writer(f.PcStackMapIndex)
-        writer(f.PcInlTreeIndex)
-        writer(f.PcArgLiveIndex)
-        
-        _f.entryOff = f.EntryOff
-        _f.nameOff = nameOffset[i]
-        _f.args = f.ArgsSize
-        _f.deferreturn = f.DeferReturn
-        // NOTICE: _func.pcdata is always as [PCDATA_UnsafePoint(0) : PCDATA_ArgLiveIndex(3)]
-        _f.npcdata = uint32(_N_PCDATA)
-        _f.cuOffset = cuOffset[i]
-        _f.funcID = f.ID
-        _f.flag = f.Flag
-        _f.nfuncdata = uint8(_N_FUNCDATA)
-    }
-
-    return
-}
-
-func registerFunction(name string, pc uintptr, textSize uintptr, fp int, args int, size uintptr, argptrs uintptr, localptrs uintptr) {} 

vendor/github.com/bytedance/sonic/loader/funcdata_go120.go

@@ -20,10 +20,6 @@
 package loader
 
 import (
-    `encoding`
-    `os`
-    `unsafe`
-
     `github.com/bytedance/sonic/internal/rt`
 )
 
@@ -51,8 +47,6 @@ type moduledata struct {
     end, gcdata, gcbss    uintptr
     types, etypes         uintptr
     rodata                uintptr
-
-    // TODO: generate funcinfo object to memory
     gofunc                uintptr // go.func.* is actual funcinfo object in image
 
     textsectmap []textSection // see runtime/symtab.go: textAddr()
@@ -118,428 +112,3 @@ type _func struct {
     //
     // funcdata [nfuncdata]uint32
 }
-
-type funcTab struct {
-    entry   uint32
-    funcoff uint32
-}
-
-type pcHeader struct {
-    magic          uint32  // 0xFFFFFFF0
-    pad1, pad2     uint8   // 0,0
-    minLC          uint8   // min instruction size
-    ptrSize        uint8   // size of a ptr in bytes
-    nfunc          int     // number of functions in the module
-    nfiles         uint    // number of entries in the file tab
-    textStart      uintptr // base for function entry PC offsets in this module, equal to moduledata.text
-    funcnameOffset uintptr // offset to the funcnametab variable from pcHeader
-    cuOffset       uintptr // offset to the cutab variable from pcHeader
-    filetabOffset  uintptr // offset to the filetab variable from pcHeader
-    pctabOffset    uintptr // offset to the pctab variable from pcHeader
-    pclnOffset     uintptr // offset to the pclntab variable from pcHeader
-}
-
-type bitVector struct {
-    n        int32 // # of bits
-    bytedata *uint8
-}
-
-type ptabEntry struct {
-    name int32
-    typ  int32
-}
-
-type textSection struct {
-    vaddr    uintptr // prelinked section vaddr
-    end      uintptr // vaddr + section length
-    baseaddr uintptr // relocated section address
-}
-
-type modulehash struct {
-    modulename   string
-    linktimehash string
-    runtimehash  *string
-}
-
-// findfuncbucket is an array of these structures.
-// Each bucket represents 4096 bytes of the text segment.
-// Each subbucket represents 256 bytes of the text segment.
-// To find a function given a pc, locate the bucket and subbucket for
-// that pc. Add together the idx and subbucket value to obtain a
-// function index. Then scan the functab array starting at that
-// index to find the target function.
-// This table uses 20 bytes for every 4096 bytes of code, or ~0.5% overhead.
-type findfuncbucket struct {
-    idx        uint32
-    _SUBBUCKETS [16]byte
-}
-
-// func name table format: 
-//   nameOff[0] -> namePartA namePartB namePartC \x00 
-//   nameOff[1] -> namePartA namePartB namePartC \x00
-//  ...
-func makeFuncnameTab(funcs []Func) (tab []byte, offs []int32) {
-    offs = make([]int32, len(funcs))
-    offset := 0
-
-    for i, f := range funcs {
-        offs[i] = int32(offset)
-
-        a, b, c := funcNameParts(f.Name)
-        tab = append(tab, a...)
-        tab = append(tab, b...)
-        tab = append(tab, c...)
-        tab = append(tab, 0)
-        offset += len(a) + len(b) + len(c) + 1
-    }
-
-    return
-}
-
-type compilationUnit struct {
-    fileNames []string
-}
-
-// CU table format:
-//  cuOffsets[0] -> filetabOffset[0] filetabOffset[1] ... filetabOffset[len(CUs[0].fileNames)-1]
-//  cuOffsets[1] -> filetabOffset[len(CUs[0].fileNames)] ... filetabOffset[len(CUs[0].fileNames) + len(CUs[1].fileNames)-1]
-//  ...
-//
-// file name table format:
-//  filetabOffset[0] -> CUs[0].fileNames[0] \x00
-//  ...
-//  filetabOffset[len(CUs[0]-1)] -> CUs[0].fileNames[len(CUs[0].fileNames)-1] \x00
-//  ...
-//  filetabOffset[SUM(CUs,fileNames)-1] -> CUs[len(CU)-1].fileNames[len(CUs[len(CU)-1].fileNames)-1] \x00
-func makeFilenametab(cus []compilationUnit) (cutab []uint32, filetab []byte, cuOffsets []uint32) {
-    cuOffsets = make([]uint32, len(cus))
-    cuOffset := 0
-    fileOffset := 0
-
-    for i, cu := range cus {
-        cuOffsets[i] = uint32(cuOffset)
-
-        for _, name := range cu.fileNames {
-            cutab = append(cutab, uint32(fileOffset))
-
-            fileOffset += len(name) + 1
-            filetab = append(filetab, name...)
-            filetab = append(filetab, 0)
-        }
-
-        cuOffset += len(cu.fileNames)
-    }
-
-    return
-}
-
-func writeFuncdata(out *[]byte, funcs []Func) (fstart int, funcdataOffs [][]uint32) {
-    fstart = len(*out)
-    *out = append(*out, byte(0))
-    offs := uint32(1)
-
-    funcdataOffs = make([][]uint32, len(funcs))
-    for i, f := range funcs {
-
-        var writer = func(fd encoding.BinaryMarshaler) {
-            var ab []byte
-            var err error
-            if fd != nil {
-                ab, err = fd.MarshalBinary()
-                if err != nil {
-                    panic(err)
-                }
-                funcdataOffs[i] = append(funcdataOffs[i], offs)
-            } else {
-                ab = []byte{0}
-                funcdataOffs[i] = append(funcdataOffs[i], _INVALID_FUNCDATA_OFFSET)
-            }
-            *out = append(*out, ab...)
-            offs += uint32(len(ab))
-        }
-
-        writer(f.ArgsPointerMaps)
-        writer(f.LocalsPointerMaps)
-        writer(f.StackObjects)
-        writer(f.InlTree)
-        writer(f.OpenCodedDeferInfo)
-        writer(f.ArgInfo)
-        writer(f.ArgLiveInfo)
-        writer(f.WrapInfo)
-    }
-    return 
-}
-
-func makeFtab(funcs []_func, lastFuncSize uint32) (ftab []funcTab) {
-    // Allocate space for the pc->func table. This structure consists of a pc offset
-    // and an offset to the func structure. After that, we have a single pc
-    // value that marks the end of the last function in the binary.
-    var size int64 = int64(len(funcs)*2*4 + 4)
-    var startLocations = make([]uint32, len(funcs))
-    for i, f := range funcs {
-        size = rnd(size, int64(_PtrSize))
-        //writePCToFunc
-        startLocations[i] = uint32(size)
-        size += int64(uint8(_FUNC_SIZE)+f.nfuncdata*4+uint8(f.npcdata)*4)
-    }
-
-    ftab = make([]funcTab, 0, len(funcs)+1)
-
-    // write a map of pc->func info offsets 
-    for i, f := range funcs {
-        ftab = append(ftab, funcTab{uint32(f.entryOff), uint32(startLocations[i])})
-    }
-
-    // Final entry of table is just end pc offset.
-    lastFunc := funcs[len(funcs)-1]
-    ftab = append(ftab, funcTab{uint32(lastFunc.entryOff + lastFuncSize), 0})
-
-    return
-}
-
-// Pcln table format: [...]funcTab + [...]_Func
-func makePclntable(funcs []_func, lastFuncSize uint32, pcdataOffs [][]uint32, funcdataOffs [][]uint32) (pclntab []byte) {
-    // Allocate space for the pc->func table. This structure consists of a pc offset
-    // and an offset to the func structure. After that, we have a single pc
-    // value that marks the end of the last function in the binary.
-    var size int64 = int64(len(funcs)*2*4 + 4)
-    var startLocations = make([]uint32, len(funcs))
-    for i := range funcs {
-        size = rnd(size, int64(_PtrSize))
-        //writePCToFunc
-        startLocations[i] = uint32(size)
-        size += int64(int(_FUNC_SIZE)+len(funcdataOffs[i])*4+len(pcdataOffs[i])*4)
-    }
-
-    pclntab = make([]byte, size, size)
-
-    // write a map of pc->func info offsets 
-    offs := 0
-    for i, f := range funcs {
-        byteOrder.PutUint32(pclntab[offs:offs+4], uint32(f.entryOff))
-        byteOrder.PutUint32(pclntab[offs+4:offs+8], uint32(startLocations[i]))
-        offs += 8
-    }
-    // Final entry of table is just end pc offset.
-    lastFunc := funcs[len(funcs)-1]
-    byteOrder.PutUint32(pclntab[offs:offs+4], uint32(lastFunc.entryOff+lastFuncSize))
-
-    // write func info table
-    for i, f := range funcs {
-        off := startLocations[i]
-
-        // write _func structure to pclntab
-        fb := rt.BytesFrom(unsafe.Pointer(&f), int(_FUNC_SIZE), int(_FUNC_SIZE))
-        copy(pclntab[off:off+uint32(_FUNC_SIZE)], fb)
-        off += uint32(_FUNC_SIZE)
-
-        // NOTICE: _func.pcdata always starts from PcUnsafePoint, which is index 3
-        for j := 3; j < len(pcdataOffs[i]); j++ {
-            byteOrder.PutUint32(pclntab[off:off+4], uint32(pcdataOffs[i][j]))
-            off += 4
-        }
-
-        // funcdata refs as offsets from gofunc
-        for _, funcdata := range funcdataOffs[i] {
-            byteOrder.PutUint32(pclntab[off:off+4], uint32(funcdata))
-            off += 4
-        }
-
-    }
-
-    return
-}
-
-// findfunc table used to map pc to belonging func, 
-// returns the index in the func table.
-//
-// All text section are divided into buckets sized _BUCKETSIZE(4K):
-//   every bucket is divided into _SUBBUCKETS sized _SUB_BUCKETSIZE(64),
-//   and it has a base idx to plus the offset stored in jth subbucket.
-// see findfunc() in runtime/symtab.go
-func writeFindfunctab(out *[]byte, ftab []funcTab) (start int) {
-    start = len(*out)
-
-    max := ftab[len(ftab)-1].entry
-    min := ftab[0].entry
-    nbuckets := (max - min + _BUCKETSIZE - 1) / _BUCKETSIZE
-    n := (max - min + _SUB_BUCKETSIZE - 1) / _SUB_BUCKETSIZE
-
-    tab := make([]findfuncbucket, 0, nbuckets)
-    var s, e = 0, 0
-    for i := 0; i<int(nbuckets); i++ {
-        var pc = min + uint32((i+1)*_BUCKETSIZE)
-        // find the end func of the bucket
-        for ; e < len(ftab)-1 && ftab[e+1].entry <= pc; e++ {}
-        // store the start func of the bucket
-        var fb = findfuncbucket{idx: uint32(s)}
-
-        for j := 0; j<_SUBBUCKETS && (i*_SUBBUCKETS+j)<int(n); j++ {
-            pc = min + uint32(i*_BUCKETSIZE) + uint32((j+1)*_SUB_BUCKETSIZE)
-            var ss = s
-            // find the end func of the subbucket
-            for ; ss < len(ftab)-1 && ftab[ss+1].entry <= pc; ss++ {}
-            // store the start func of the subbucket
-            fb._SUBBUCKETS[j] = byte(uint32(s) - fb.idx)
-            s = ss
-        }
-        s = e
-        tab = append(tab, fb)
-    }
-
-    // write findfuncbucket
-    if len(tab) > 0 {
-        size := int(unsafe.Sizeof(findfuncbucket{}))*len(tab)
-        *out = append(*out, rt.BytesFrom(unsafe.Pointer(&tab[0]), size, size)...)
-    }
-    return 
-}
-
-func makeModuledata(name string, filenames []string, funcs []Func, text []byte) (mod *moduledata) {
-    mod = new(moduledata)
-    mod.modulename = name
-
-    // make filename table
-    cu := make([]string, 0, len(filenames))
-    for _, f := range filenames {
-        cu = append(cu, f)
-    }
-    cutab, filetab, cuOffs := makeFilenametab([]compilationUnit{{cu}})
-    mod.cutab = cutab
-    mod.filetab = filetab
-
-    // make funcname table
-    funcnametab, nameOffs := makeFuncnameTab(funcs)
-    mod.funcnametab = funcnametab
-
-    // make pcdata table
-    // NOTICE: _func only use offset to index pcdata, thus no need mmap() pcdata 
-    pctab, pcdataOffs, _funcs := makePctab(funcs, cuOffs, nameOffs)
-    mod.pctab = pctab
-
-    // write func data
-    // NOTICE: _func use mod.gofunc+offset to directly point funcdata, thus need cache funcdata
-    // TODO: estimate accurate capacity
-    cache := make([]byte, 0, len(funcs)*int(_PtrSize)) 
-    fstart, funcdataOffs := writeFuncdata(&cache, funcs)
-
-    // make pc->func (binary search) func table
-    lastFuncsize := funcs[len(funcs)-1].TextSize
-    ftab := makeFtab(_funcs, lastFuncsize)
-    mod.ftab = ftab
-
-    // write pc->func (modmap) findfunc table
-    ffstart := writeFindfunctab(&cache, ftab)
-
-    // make pclnt table
-    pclntab := makePclntable(_funcs, lastFuncsize, pcdataOffs, funcdataOffs)
-    mod.pclntable = pclntab
-
-    // mmap() text and funcdata segements
-    p := os.Getpagesize()
-    size := int(rnd(int64(len(text)), int64(p)))
-    addr := mmap(size)
-    // copy the machine code
-    s := rt.BytesFrom(unsafe.Pointer(addr), len(text), size)
-    copy(s, text)
-    // make it executable
-    mprotect(addr, size)
-
-    // assign addresses
-    mod.text = addr
-    mod.etext = addr + uintptr(size)
-    mod.minpc = addr
-    mod.maxpc = addr + uintptr(len(text))
-
-    // cache funcdata and findfuncbucket
-    moduleCache.Lock()
-    moduleCache.m[mod] = cache
-    moduleCache.Unlock()
-    mod.gofunc = uintptr(unsafe.Pointer(&cache[fstart]))
-    mod.findfunctab = uintptr(unsafe.Pointer(&cache[ffstart]))
-
-    // make pc header
-    mod.pcHeader = &pcHeader {
-        magic   : _Magic,
-        minLC   : _MinLC,
-        ptrSize : _PtrSize,
-        nfunc   : len(funcs),
-        nfiles: uint(len(cu)),
-        textStart: mod.text,
-        funcnameOffset: getOffsetOf(moduledata{}, "funcnametab"),
-        cuOffset: getOffsetOf(moduledata{}, "cutab"),
-        filetabOffset: getOffsetOf(moduledata{}, "filetab"),
-        pctabOffset: getOffsetOf(moduledata{}, "pctab"),
-        pclnOffset: getOffsetOf(moduledata{}, "pclntable"),
-    }
-
-    // sepecial case: gcdata and gcbss must by non-empty
-    mod.gcdata = uintptr(unsafe.Pointer(&emptyByte))
-    mod.gcbss = uintptr(unsafe.Pointer(&emptyByte))
-
-    return
-}
-
-// makePctab generates pcdelta->valuedelta tables for functions,
-// and returns the table and the entry offset of every kind pcdata in the table.
-func makePctab(funcs []Func, cuOffset []uint32, nameOffset []int32) (pctab []byte, pcdataOffs [][]uint32, _funcs []_func) {
-    _funcs = make([]_func, len(funcs))
-
-    // Pctab offsets of 0 are considered invalid in the runtime. We respect
-    // that by just padding a single byte at the beginning of runtime.pctab,
-    // that way no real offsets can be zero.
-    pctab = make([]byte, 1, 12*len(funcs)+1)
-    pcdataOffs = make([][]uint32, len(funcs))
-
-    for i, f := range funcs {
-        _f := &_funcs[i]
-
-        var writer = func(pc *Pcdata) {
-            var ab []byte
-            var err error
-            if pc != nil {
-                ab, err = pc.MarshalBinary()
-                if err != nil {
-                    panic(err)
-                }
-                pcdataOffs[i] = append(pcdataOffs[i], uint32(len(pctab)))
-            } else {
-                ab = []byte{0}
-                pcdataOffs[i] = append(pcdataOffs[i], _PCDATA_INVALID_OFFSET)
-            }
-            pctab = append(pctab, ab...)
-        }
-
-        if f.Pcsp != nil {
-            _f.pcsp = uint32(len(pctab))
-        }
-        writer(f.Pcsp)
-        if f.Pcfile != nil {
-            _f.pcfile = uint32(len(pctab))
-        }
-        writer(f.Pcfile)
-        if f.Pcline != nil {
-            _f.pcln = uint32(len(pctab))
-        }
-        writer(f.Pcline)
-        writer(f.PcUnsafePoint)
-        writer(f.PcStackMapIndex)
-        writer(f.PcInlTreeIndex)
-        writer(f.PcArgLiveIndex)
-        
-        _f.entryOff = f.EntryOff
-        _f.nameOff = nameOffset[i]
-        _f.args = f.ArgsSize
-        _f.deferreturn = f.DeferReturn
-        // NOTICE: _func.pcdata is always as [PCDATA_UnsafePoint(0) : PCDATA_ArgLiveIndex(3)]
-        _f.npcdata = uint32(_N_PCDATA)
-        _f.cuOffset = cuOffset[i]
-        _f.funcID = f.ID
-        _f.flag = f.Flag
-        _f.nfuncdata = uint8(_N_FUNCDATA)
-    }
-
-    return
-}
-
-func registerFunction(name string, pc uintptr, textSize uintptr, fp int, args int, size uintptr, argptrs uintptr, localptrs uintptr) {}

vendor/github.com/bytedance/sonic/loader/loader_go115.go

@@ -1,28 +0,0 @@
-//go:build go1.15 && !go1.16
-// +build go1.15,!go1.16
-
-/*
- * Copyright 2021 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 (
-    `github.com/bytedance/sonic/internal/loader`
-)
-
-func (self Loader) LoadOne(text []byte, funcName string, frameSize int, argSize int, argStackmap []bool, localStackmap []bool) Function {
-    return Function(loader.Loader(text).Load(funcName, frameSize, argSize, argStackmap, localStackmap))
-}

vendor/github.com/bytedance/sonic/loader/loader_go116.go

@@ -1,104 +0,0 @@
-//go:build go1.16 && !go1.21
-// +build go1.16,!go1.21
-
-/*
- * Copyright 2021 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 (
-    `github.com/bytedance/sonic/internal/rt`
-)
-
-// LoadFuncs loads only one function as module, and returns the function pointer
-//   - text: machine code
-//   - funcName: function name
-//   - frameSize: stack frame size. 
-//   - argSize: argument total size (in bytes)
-//   - argPtrs: indicates if a slot (8 Bytes) of arguments memory stores pointer, from low to high
-//   - localPtrs: indicates if a slot (8 Bytes) of local variants memory stores pointer, from low to high
-// 
-// WARN: 
-//   - the function MUST has fixed SP offset equaling to this, otherwise it go.gentraceback will fail
-//   - the function MUST has only one stack map for all arguments and local variants
-func (self Loader) LoadOne(text []byte, funcName string, frameSize int, argSize int, argPtrs []bool, localPtrs []bool) Function {
-    size := uint32(len(text))
-
-    fn := Func{
-        Name: funcName,
-        TextSize: size,
-        ArgsSize: int32(argSize),
-    }
-
-    // NOTICE: suppose the function has fixed SP offset equaling to frameSize, thus make only one pcsp pair
-    fn.Pcsp = &Pcdata{
-        {PC: size, Val: int32(frameSize)},
-    }
-
-    if self.NoPreempt {
-        fn.PcUnsafePoint = &Pcdata{
-            {PC: size, Val: PCDATA_UnsafePointUnsafe},
-        }
-    } else {
-        fn.PcUnsafePoint = &Pcdata{
-            {PC: size, Val: PCDATA_UnsafePointSafe},
-        }
-    }
-
-    // NOTICE: suppose the function has only one stack map at index 0
-    fn.PcStackMapIndex = &Pcdata{
-        {PC: size, Val: 0},
-    }
-
-    if argPtrs != nil {
-        args := rt.StackMapBuilder{}
-        for _, b := range argPtrs {
-            args.AddField(b)
-        }
-        fn.ArgsPointerMaps = args.Build()
-    }
-    
-    if localPtrs != nil {
-        locals := rt .StackMapBuilder{}
-        for _, b := range localPtrs {
-            locals.AddField(b)
-        }
-        fn.LocalsPointerMaps = locals.Build()
-    }
-
-    out := Load(text, []Func{fn}, self.Name + funcName, []string{self.File})
-    return out[0]
-}
-
-// Load loads given machine codes and corresponding function information into go moduledata
-// and returns runnable function pointer
-// WARN: this API is experimental, use it carefully
-func Load(text []byte, funcs []Func, modulename string, filenames []string) (out []Function) {
-    // generate module data and allocate memory address
-    mod := makeModuledata(modulename, filenames, funcs, text)
-
-    // verify and register the new module
-    moduledataverify1(mod)
-    registerModule(mod)
-
-    // encapsulate function address
-    out = make([]Function, len(funcs))
-    for i, f := range funcs {
-        m := uintptr(mod.text + uintptr(f.EntryOff))
-        out[i] = Function(&m)
-    }
-    return 
-}

vendor/github.com/bytedance/sonic/loader/pcdata.go

@@ -16,6 +16,10 @@
 
 package loader
 
+import (
+    `encoding/binary`
+)
+
 const (
     _N_PCDATA   = 4
 
@@ -49,40 +53,16 @@ const (
 
 var emptyByte byte
 
-func encodeValue(v int) []byte {
-    return encodeVariant(toZigzag(v))
-}
-
-func toZigzag(v int) int {
-    return (v << 1) ^ (v >> 31)
-}
-
-func encodeVariant(v int) []byte {
-    var u int
-    var r []byte
-
-    /* split every 7 bits */
-    for v > 127 {
-        u = v & 0x7f
-        v = v >> 7
-        r = append(r, byte(u) | 0x80)
-    }
-
-    /* check for last one */
-    if v == 0 {
-        return r
-    }
-
-    /* add the last one */
-    r = append(r, byte(v))
-    return r
-}
-
+// Pcvalue is the program count corresponding to the value Val
+//   WARN: we use relative value here (to function entry)
 type Pcvalue struct {
-    PC  uint32 // PC offset from func entry
-    Val int32
+    PC  uint32 // program count relative to function entry
+    Val int32  // value relative to the value in function entry
 }
 
+// Pcdata represents pc->value mapping table.
+//   WARN: we use ** [Pcdata[i].PC, Pcdata[i+1].PC) **
+//   as the range where the Pcdata[i].Val is effective.
 type Pcdata []Pcvalue
 
 // see https://docs.google.com/document/d/1lyPIbmsYbXnpNj57a261hgOYVpNRcgydurVQIyZOz_o/pub
@@ -90,11 +70,24 @@ func (self Pcdata) MarshalBinary() (data []byte, err error) {
     // delta value always starts from -1
     sv := int32(_PCDATA_START_VAL)
     sp := uint32(0)
+    buf := make([]byte, binary.MaxVarintLen32)
     for _, v := range self {
-        data = append(data, encodeVariant(toZigzag(int(v.Val - sv)))...)
-        data = append(data, encodeVariant(int(v.PC - sp))...)
+        if v.PC < sp {
+            panic("PC must be in ascending order!")
+        }
+        dp := uint64(v.PC - sp)
+        dv := int64(v.Val - sv)
+        if dv == 0 || dp == 0 {
+            continue
+        }
+        n := binary.PutVarint(buf, dv)
+        data = append(data, buf[:n]...)
+        n2 := binary.PutUvarint(buf, dp)
+        data = append(data, buf[:n2]...)
         sp = v.PC
         sv = v.Val
     }
+    // put 0 to indicate ends
+    data = append(data, 0)
     return
 }

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

@@ -1,4 +1,4 @@
-// +build amd64,go1.15,!go1.21
+// +build amd64,go1.16,!go1.22
 
 /*
  * Copyright 2021 ByteDance Inc.

vendor/github.com/chenzhuoyu/base64x/Makefile

@@ -19,10 +19,11 @@ NATIVE_SRC += $(wildcard native/*.c)
 all: native_amd64.s
 
 clean:
-	rm -vf native_amd64.s output/*.s
+	rm -vf native_text_amd64.go native_subr_amd64.go output/*.s
 
 native_amd64.s: ${NATIVE_SRC} ${NATIVE_ASM} native_amd64.go
 	mkdir -p output
 	clang ${CFLAGS} -S -o output/native.s native/native.c
-	python3 tools/asm2asm/asm2asm.py native_amd64.s output/native.s ${NATIVE_ASM}
-	asmfmt -w native_amd64.s
+	python3 tools/asm2asm/asm2asm.py -r native_amd64.go output/native.s ${NATIVE_ASM}
+	awk '{gsub(/Text__native_entry__/, "text__native_entry__")}1' native_text_amd64.go > native_text_amd64.go.tmp && mv native_text_amd64.go.tmp native_text_amd64.go
+	awk '{gsub(/Funcs/, "funcs")}1' native_subr_amd64.go > native_subr_amd64.go.tmp && mv native_subr_amd64.go.tmp native_subr_amd64.go

vendor/github.com/chenzhuoyu/base64x/base64x.go

@@ -71,7 +71,7 @@ func (self Encoding) Encode(out []byte, src []byte) {
 //
 // It will also update the length of out.
 func (self Encoding) EncodeUnsafe(out *[]byte, src []byte) {
-    __b64encode(out, &src, int(self) | archFlags)
+    b64encode(out, &src, int(self) | archFlags)
 }
 
 // EncodeToString returns the base64 encoding of src.
@@ -120,7 +120,7 @@ func (self Encoding) Decode(out []byte, src []byte) (int, error) {
 //
 // It will also update the length of out.
 func (self Encoding) DecodeUnsafe(out *[]byte, src []byte) (int, error) {
-    if n := __b64decode(out, mem2addr(src), len(src), int(self) | archFlags); n >= 0 {
+    if n := b64decode(out, mem2addr(src), len(src), int(self) | archFlags); n >= 0 {
         return n, nil
     } else {
         return 0, base64.CorruptInputError(-n - 1)
@@ -149,9 +149,3 @@ func (self Encoding) DecodedLen(n int) int {
         return n * 6 / 8
     }
 }
-
-func init() {
-    if hasAVX2() {
-        archFlags = _MODE_AVX2
-    }
-}

vendor/github.com/chenzhuoyu/base64x/faststr.go

@@ -21,3 +21,15 @@ func str2mem(s string) (v []byte) {
 func mem2addr(v []byte) unsafe.Pointer {
     return *(*unsafe.Pointer)(unsafe.Pointer(&v))
 }
+
+// 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/chenzhuoyu/base64x/native_amd64.go

@@ -3,14 +3,40 @@ package base64x
 
 import (
     `unsafe`
+
+    `github.com/bytedance/sonic/loader`
 )
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __b64encode(out *[]byte, src *[]byte, mode int)
+func b64encode(out *[]byte, src *[]byte, mode int) {
+    __b64encode(noEscape(unsafe.Pointer(out)), noEscape(unsafe.Pointer(src)), mode)
+}
 
 //go:nosplit
-//go:noescape
-//goland:noinspection GoUnusedParameter
-func __b64decode(out *[]byte, src unsafe.Pointer, len int, mode int) (ret int)
+func b64decode(out *[]byte, src unsafe.Pointer, len int, mode int) (ret int) {
+    return __b64decode(noEscape(unsafe.Pointer(out)), noEscape(unsafe.Pointer(src)), len, mode)
+}
+
+// asm2asm templates
+var (
+    __b64encode func(out unsafe.Pointer, src unsafe.Pointer, mod int)
+    __b64decode func(out unsafe.Pointer, src unsafe.Pointer, len int, mod int) (ret int)
+)
+
+// directly jump PCs
+var (
+    _subr__b64encode uintptr
+    _subr__b64decode uintptr
+)
+
+var stubs = []loader.GoC{
+    {"_b64encode", &_subr__b64encode, &__b64encode},
+    {"_b64decode", &_subr__b64decode, &__b64decode},
+}
+
+func init() {
+    if hasAVX2() {
+        archFlags = _MODE_AVX2
+    }
+    loader.WrapGoC(text__native_entry__, funcs, stubs, "base64x", "base64x/native.c")
+}

vendor/github.com/chenzhuoyu/base64x/native_subr_amd64.go

@@ -3,27 +3,61 @@
 
 package base64x
 
-//go:nosplit
-//go:noescape
-//goland:noinspection ALL
-func __native_entry__() uintptr
-
-var (
-    _subr__b64decode = __native_entry__() + 1563
-    _subr__b64encode = __native_entry__() + 301
+import (
+	`github.com/bytedance/sonic/loader`
 )
 
 const (
-    _stack__b64decode = 128
+    _entry__b64decode = 1328
+    _entry__b64encode = 256
+)
+
+const (
+    _stack__b64decode = 152
     _stack__b64encode = 40
 )
 
-var (
-    _ = _subr__b64decode
-    _ = _subr__b64encode
+const (
+    _size__b64decode = 17616
+    _size__b64encode = 864
 )
 
-const (
-    _ = _stack__b64decode
-    _ = _stack__b64encode
+var (
+    _pcsp__b64decode = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {12, 40},
+        {13, 48},
+        {17560, 152},
+        {17564, 48},
+        {17565, 40},
+        {17567, 32},
+        {17569, 24},
+        {17571, 16},
+        {17573, 8},
+        {17577, 0},
+        {17608, 152},
+    }
+    _pcsp__b64encode = [][2]uint32{
+        {1, 0},
+        {4, 8},
+        {6, 16},
+        {8, 24},
+        {10, 32},
+        {852, 40},
+        {853, 32},
+        {855, 24},
+        {857, 16},
+        {859, 8},
+        {864, 0},
+    }
 )
+
+var funcs = []loader.CFunc{
+    {"__native_entry__", 0, 67, 0, nil},
+    {"_b64decode", _entry__b64decode, _size__b64decode, _stack__b64decode, _pcsp__b64decode},
+    {"_b64encode", _entry__b64encode, _size__b64encode, _stack__b64encode, _pcsp__b64encode},
+}

vendor/github.com/klauspost/cpuid/v2/README.md

@@ -435,6 +435,7 @@ Exit Code 1
 | SYSCALL            | System-Call Extension (SCE): SYSCALL and SYSRET instructions.                                                                                                                      |
 | SYSEE              | SYSENTER and SYSEXIT instructions                                                                                                                                                  |
 | TBM                | AMD Trailing Bit Manipulation                                                                                                                                                      |
+| TDX_GUEST          | Intel Trust Domain Extensions Guest                                                                                                                                                |
 | TLB_FLUSH_NESTED   | AMD: Flushing includes all the nested translations for guest translations                                                                                                          |
 | TME                | Intel Total Memory Encryption. The following MSRs are supported: IA32_TME_CAPABILITY, IA32_TME_ACTIVATE, IA32_TME_EXCLUDE_MASK, and IA32_TME_EXCLUDE_BASE.                         |
 | TOPEXT             | TopologyExtensions: topology extensions support. Indicates support for CPUID Fn8000_001D_EAX_x[N:0]-CPUID Fn8000_001E_EDX.                                                         |

vendor/github.com/klauspost/cpuid/v2/cpuid.go

@@ -226,6 +226,7 @@ const (
 	SYSCALL                             // System-Call Extension (SCE): SYSCALL and SYSRET instructions.
 	SYSEE                               // SYSENTER and SYSEXIT instructions
 	TBM                                 // AMD Trailing Bit Manipulation
+	TDX_GUEST                           // Intel Trust Domain Extensions Guest
 	TLB_FLUSH_NESTED                    // AMD: Flushing includes all the nested translations for guest translations
 	TME                                 // Intel Total Memory Encryption. The following MSRs are supported: IA32_TME_CAPABILITY, IA32_TME_ACTIVATE, IA32_TME_EXCLUDE_MASK, and IA32_TME_EXCLUDE_BASE.
 	TOPEXT                              // TopologyExtensions: topology extensions support. Indicates support for CPUID Fn8000_001D_EAX_x[N:0]-CPUID Fn8000_001E_EDX.
@@ -1186,13 +1187,8 @@ func support() flagSet {
 		fs.setIf(edx&(1<<30) != 0, IA32_CORE_CAP)
 		fs.setIf(edx&(1<<31) != 0, SPEC_CTRL_SSBD)
 
-		// CPUID.(EAX=7, ECX=1).EDX
-		fs.setIf(edx&(1<<4) != 0, AVXVNNIINT8)
-		fs.setIf(edx&(1<<5) != 0, AVXNECONVERT)
-		fs.setIf(edx&(1<<14) != 0, PREFETCHI)
-
 		// CPUID.(EAX=7, ECX=1).EAX
-		eax1, _, _, _ := cpuidex(7, 1)
+		eax1, _, _, edx1 := cpuidex(7, 1)
 		fs.setIf(fs.inSet(AVX) && eax1&(1<<4) != 0, AVXVNNI)
 		fs.setIf(eax1&(1<<7) != 0, CMPCCXADD)
 		fs.setIf(eax1&(1<<10) != 0, MOVSB_ZL)
@@ -1202,6 +1198,11 @@ func support() flagSet {
 		fs.setIf(eax1&(1<<23) != 0, AVXIFMA)
 		fs.setIf(eax1&(1<<26) != 0, LAM)
 
+		// CPUID.(EAX=7, ECX=1).EDX
+		fs.setIf(edx1&(1<<4) != 0, AVXVNNIINT8)
+		fs.setIf(edx1&(1<<5) != 0, AVXNECONVERT)
+		fs.setIf(edx1&(1<<14) != 0, PREFETCHI)
+
 		// Only detect AVX-512 features if XGETBV is supported
 		if c&((1<<26)|(1<<27)) == (1<<26)|(1<<27) {
 			// Check for OS support
@@ -1393,6 +1394,13 @@ func support() flagSet {
 		fs.setIf((a>>24)&1 == 1, VMSA_REGPROT)
 	}
 
+	if mfi >= 0x21 {
+		// Intel Trusted Domain Extensions Guests have their own cpuid leaf (0x21).
+		_, ebx, ecx, edx := cpuid(0x21)
+		identity := string(valAsString(ebx, edx, ecx))
+		fs.setIf(identity == "IntelTDX    ", TDX_GUEST)
+	}
+
 	return fs
 }
 

vendor/github.com/klauspost/cpuid/v2/featureid_string.go

@@ -166,59 +166,60 @@ func _() {
 	_ = x[SYSCALL-156]
 	_ = x[SYSEE-157]
 	_ = x[TBM-158]
-	_ = x[TLB_FLUSH_NESTED-159]
-	_ = x[TME-160]
-	_ = x[TOPEXT-161]
-	_ = x[TSCRATEMSR-162]
-	_ = x[TSXLDTRK-163]
-	_ = x[VAES-164]
-	_ = x[VMCBCLEAN-165]
-	_ = x[VMPL-166]
-	_ = x[VMSA_REGPROT-167]
-	_ = x[VMX-168]
-	_ = x[VPCLMULQDQ-169]
-	_ = x[VTE-170]
-	_ = x[WAITPKG-171]
-	_ = x[WBNOINVD-172]
-	_ = x[WRMSRNS-173]
-	_ = x[X87-174]
-	_ = x[XGETBV1-175]
-	_ = x[XOP-176]
-	_ = x[XSAVE-177]
-	_ = x[XSAVEC-178]
-	_ = x[XSAVEOPT-179]
-	_ = x[XSAVES-180]
-	_ = x[AESARM-181]
-	_ = x[ARMCPUID-182]
-	_ = x[ASIMD-183]
-	_ = x[ASIMDDP-184]
-	_ = x[ASIMDHP-185]
-	_ = x[ASIMDRDM-186]
-	_ = x[ATOMICS-187]
-	_ = x[CRC32-188]
-	_ = x[DCPOP-189]
-	_ = x[EVTSTRM-190]
-	_ = x[FCMA-191]
-	_ = x[FP-192]
-	_ = x[FPHP-193]
-	_ = x[GPA-194]
-	_ = x[JSCVT-195]
-	_ = x[LRCPC-196]
-	_ = x[PMULL-197]
-	_ = x[SHA1-198]
-	_ = x[SHA2-199]
-	_ = x[SHA3-200]
-	_ = x[SHA512-201]
-	_ = x[SM3-202]
-	_ = x[SM4-203]
-	_ = x[SVE-204]
-	_ = x[lastID-205]
+	_ = x[TDX_GUEST-159]
+	_ = x[TLB_FLUSH_NESTED-160]
+	_ = x[TME-161]
+	_ = x[TOPEXT-162]
+	_ = x[TSCRATEMSR-163]
+	_ = x[TSXLDTRK-164]
+	_ = x[VAES-165]
+	_ = x[VMCBCLEAN-166]
+	_ = x[VMPL-167]
+	_ = x[VMSA_REGPROT-168]
+	_ = x[VMX-169]
+	_ = x[VPCLMULQDQ-170]
+	_ = x[VTE-171]
+	_ = x[WAITPKG-172]
+	_ = x[WBNOINVD-173]
+	_ = x[WRMSRNS-174]
+	_ = x[X87-175]
+	_ = x[XGETBV1-176]
+	_ = x[XOP-177]
+	_ = x[XSAVE-178]
+	_ = x[XSAVEC-179]
+	_ = x[XSAVEOPT-180]
+	_ = x[XSAVES-181]
+	_ = x[AESARM-182]
+	_ = x[ARMCPUID-183]
+	_ = x[ASIMD-184]
+	_ = x[ASIMDDP-185]
+	_ = x[ASIMDHP-186]
+	_ = x[ASIMDRDM-187]
+	_ = x[ATOMICS-188]
+	_ = x[CRC32-189]
+	_ = x[DCPOP-190]
+	_ = x[EVTSTRM-191]
+	_ = x[FCMA-192]
+	_ = x[FP-193]
+	_ = x[FPHP-194]
+	_ = x[GPA-195]
+	_ = x[JSCVT-196]
+	_ = x[LRCPC-197]
+	_ = x[PMULL-198]
+	_ = x[SHA1-199]
+	_ = x[SHA2-200]
+	_ = x[SHA3-201]
+	_ = x[SHA512-202]
+	_ = x[SM3-203]
+	_ = x[SM4-204]
+	_ = x[SVE-205]
+	_ = x[lastID-206]
 	_ = x[firstID-0]
 }
 
-const _FeatureID_name = "firstIDADXAESNIAMD3DNOWAMD3DNOWEXTAMXBF16AMXFP16AMXINT8AMXTILEAVXAVX2AVX512BF16AVX512BITALGAVX512BWAVX512CDAVX512DQAVX512ERAVX512FAVX512FP16AVX512IFMAAVX512PFAVX512VBMIAVX512VBMI2AVX512VLAVX512VNNIAVX512VP2INTERSECTAVX512VPOPCNTDQAVXIFMAAVXNECONVERTAVXSLOWAVXVNNIAVXVNNIINT8BHI_CTRLBMI1BMI2CETIBTCETSSCLDEMOTECLMULCLZEROCMOVCMPCCXADDCMPSB_SCADBS_SHORTCMPXCHG8CPBOOSTCPPCCX16EFER_LMSLE_UNSENQCMDERMSF16CFLUSH_L1DFMA3FMA4FP128FP256FSRMFXSRFXSROPTGFNIHLEHRESETHTTHWAHYBRID_CPUHYPERVISORIA32_ARCH_CAPIA32_CORE_CAPIBPBIBRSIBRS_PREFERREDIBRS_PROVIDES_SMPIBSIBSBRNTRGTIBSFETCHSAMIBSFFVIBSOPCNTIBSOPCNTEXTIBSOPSAMIBSRDWROPCNTIBSRIPINVALIDCHKIBS_FETCH_CTLXIBS_OPDATA4IBS_OPFUSEIBS_PREVENTHOSTIBS_ZEN4IDPRED_CTRLINT_WBINVDINVLPGBLAHFLAMLBRVIRTLZCNTMCAOVERFLOWMCDT_NOMCOMMITMD_CLEARMMXMMXEXTMOVBEMOVDIR64BMOVDIRIMOVSB_ZLMOVUMPXMSRIRCMSRLISTMSR_PAGEFLUSHNRIPSNXOSXSAVEPCONFIGPOPCNTPPINPREFETCHIPSFDRDPRURDRANDRDSEEDRDTSCPRRSBA_CTRLRTMRTM_ALWAYS_ABORTSERIALIZESEVSEV_64BITSEV_ALTERNATIVESEV_DEBUGSWAPSEV_ESSEV_RESTRICTEDSEV_SNPSGXSGXLCSHASMESME_COHERENTSPEC_CTRL_SSBDSRBDS_CTRLSSESSE2SSE3SSE4SSE42SSE4ASSSE3STIBPSTIBP_ALWAYSONSTOSB_SHORTSUCCORSVMSVMDASVMFBASIDSVMLSVMNPSVMPFSVMPFTSYSCALLSYSEETBMTLB_FLUSH_NESTEDTMETOPEXTTSCRATEMSRTSXLDTRKVAESVMCBCLEANVMPLVMSA_REGPROTVMXVPCLMULQDQVTEWAITPKGWBNOINVDWRMSRNSX87XGETBV1XOPXSAVEXSAVECXSAVEOPTXSAVESAESARMARMCPUIDASIMDASIMDDPASIMDHPASIMDRDMATOMICSCRC32DCPOPEVTSTRMFCMAFPFPHPGPAJSCVTLRCPCPMULLSHA1SHA2SHA3SHA512SM3SM4SVElastID"
+const _FeatureID_name = "firstIDADXAESNIAMD3DNOWAMD3DNOWEXTAMXBF16AMXFP16AMXINT8AMXTILEAVXAVX2AVX512BF16AVX512BITALGAVX512BWAVX512CDAVX512DQAVX512ERAVX512FAVX512FP16AVX512IFMAAVX512PFAVX512VBMIAVX512VBMI2AVX512VLAVX512VNNIAVX512VP2INTERSECTAVX512VPOPCNTDQAVXIFMAAVXNECONVERTAVXSLOWAVXVNNIAVXVNNIINT8BHI_CTRLBMI1BMI2CETIBTCETSSCLDEMOTECLMULCLZEROCMOVCMPCCXADDCMPSB_SCADBS_SHORTCMPXCHG8CPBOOSTCPPCCX16EFER_LMSLE_UNSENQCMDERMSF16CFLUSH_L1DFMA3FMA4FP128FP256FSRMFXSRFXSROPTGFNIHLEHRESETHTTHWAHYBRID_CPUHYPERVISORIA32_ARCH_CAPIA32_CORE_CAPIBPBIBRSIBRS_PREFERREDIBRS_PROVIDES_SMPIBSIBSBRNTRGTIBSFETCHSAMIBSFFVIBSOPCNTIBSOPCNTEXTIBSOPSAMIBSRDWROPCNTIBSRIPINVALIDCHKIBS_FETCH_CTLXIBS_OPDATA4IBS_OPFUSEIBS_PREVENTHOSTIBS_ZEN4IDPRED_CTRLINT_WBINVDINVLPGBLAHFLAMLBRVIRTLZCNTMCAOVERFLOWMCDT_NOMCOMMITMD_CLEARMMXMMXEXTMOVBEMOVDIR64BMOVDIRIMOVSB_ZLMOVUMPXMSRIRCMSRLISTMSR_PAGEFLUSHNRIPSNXOSXSAVEPCONFIGPOPCNTPPINPREFETCHIPSFDRDPRURDRANDRDSEEDRDTSCPRRSBA_CTRLRTMRTM_ALWAYS_ABORTSERIALIZESEVSEV_64BITSEV_ALTERNATIVESEV_DEBUGSWAPSEV_ESSEV_RESTRICTEDSEV_SNPSGXSGXLCSHASMESME_COHERENTSPEC_CTRL_SSBDSRBDS_CTRLSSESSE2SSE3SSE4SSE42SSE4ASSSE3STIBPSTIBP_ALWAYSONSTOSB_SHORTSUCCORSVMSVMDASVMFBASIDSVMLSVMNPSVMPFSVMPFTSYSCALLSYSEETBMTDX_GUESTTLB_FLUSH_NESTEDTMETOPEXTTSCRATEMSRTSXLDTRKVAESVMCBCLEANVMPLVMSA_REGPROTVMXVPCLMULQDQVTEWAITPKGWBNOINVDWRMSRNSX87XGETBV1XOPXSAVEXSAVECXSAVEOPTXSAVESAESARMARMCPUIDASIMDASIMDDPASIMDHPASIMDRDMATOMICSCRC32DCPOPEVTSTRMFCMAFPFPHPGPAJSCVTLRCPCPMULLSHA1SHA2SHA3SHA512SM3SM4SVElastID"
 
-var _FeatureID_index = [...]uint16{0, 7, 10, 15, 23, 34, 41, 48, 55, 62, 65, 69, 79, 91, 99, 107, 115, 123, 130, 140, 150, 158, 168, 179, 187, 197, 215, 230, 237, 249, 256, 263, 274, 282, 286, 290, 296, 301, 309, 314, 320, 324, 333, 351, 359, 366, 370, 374, 388, 394, 398, 402, 411, 415, 419, 424, 429, 433, 437, 444, 448, 451, 457, 460, 463, 473, 483, 496, 509, 513, 517, 531, 548, 551, 561, 572, 578, 586, 597, 605, 617, 633, 647, 658, 668, 683, 691, 702, 712, 719, 723, 726, 733, 738, 749, 756, 763, 771, 774, 780, 785, 794, 801, 809, 813, 816, 822, 829, 842, 847, 849, 856, 863, 869, 873, 882, 886, 891, 897, 903, 909, 919, 922, 938, 947, 950, 959, 974, 987, 993, 1007, 1014, 1017, 1022, 1025, 1028, 1040, 1054, 1064, 1067, 1071, 1075, 1079, 1084, 1089, 1094, 1099, 1113, 1124, 1130, 1133, 1138, 1147, 1151, 1156, 1161, 1167, 1174, 1179, 1182, 1198, 1201, 1207, 1217, 1225, 1229, 1238, 1242, 1254, 1257, 1267, 1270, 1277, 1285, 1292, 1295, 1302, 1305, 1310, 1316, 1324, 1330, 1336, 1344, 1349, 1356, 1363, 1371, 1378, 1383, 1388, 1395, 1399, 1401, 1405, 1408, 1413, 1418, 1423, 1427, 1431, 1435, 1441, 1444, 1447, 1450, 1456}
+var _FeatureID_index = [...]uint16{0, 7, 10, 15, 23, 34, 41, 48, 55, 62, 65, 69, 79, 91, 99, 107, 115, 123, 130, 140, 150, 158, 168, 179, 187, 197, 215, 230, 237, 249, 256, 263, 274, 282, 286, 290, 296, 301, 309, 314, 320, 324, 333, 351, 359, 366, 370, 374, 388, 394, 398, 402, 411, 415, 419, 424, 429, 433, 437, 444, 448, 451, 457, 460, 463, 473, 483, 496, 509, 513, 517, 531, 548, 551, 561, 572, 578, 586, 597, 605, 617, 633, 647, 658, 668, 683, 691, 702, 712, 719, 723, 726, 733, 738, 749, 756, 763, 771, 774, 780, 785, 794, 801, 809, 813, 816, 822, 829, 842, 847, 849, 856, 863, 869, 873, 882, 886, 891, 897, 903, 909, 919, 922, 938, 947, 950, 959, 974, 987, 993, 1007, 1014, 1017, 1022, 1025, 1028, 1040, 1054, 1064, 1067, 1071, 1075, 1079, 1084, 1089, 1094, 1099, 1113, 1124, 1130, 1133, 1138, 1147, 1151, 1156, 1161, 1167, 1174, 1179, 1182, 1191, 1207, 1210, 1216, 1226, 1234, 1238, 1247, 1251, 1263, 1266, 1276, 1279, 1286, 1294, 1301, 1304, 1311, 1314, 1319, 1325, 1333, 1339, 1345, 1353, 1358, 1365, 1372, 1380, 1387, 1392, 1397, 1404, 1408, 1410, 1414, 1417, 1422, 1427, 1432, 1436, 1440, 1444, 1450, 1453, 1456, 1459, 1465}
 
 func (i FeatureID) String() string {
 	if i < 0 || i >= FeatureID(len(_FeatureID_index)-1) {

vendor/github.com/pelletier/go-toml/v2/ci.sh

@@ -79,6 +79,7 @@ cover() {
     go test -covermode=atomic  -coverpkg=./... -coverprofile=coverage.out.tmp ./...
     cat coverage.out.tmp | grep -v fuzz | grep -v testsuite | grep -v tomltestgen | grep -v gotoml-test-decoder > coverage.out
     go tool cover -func=coverage.out
+    echo "Coverage profile for ${branch}: ${dir}/coverage.out" >&2
     popd
 
     if [ "${branch}" != "HEAD" ]; then

vendor/github.com/pelletier/go-toml/v2/marshaler.go

@@ -273,7 +273,7 @@ func (enc *Encoder) encode(b []byte, ctx encoderCtx, v reflect.Value) ([]byte, e
 		return enc.encodeMap(b, ctx, v)
 	case reflect.Struct:
 		return enc.encodeStruct(b, ctx, v)
-	case reflect.Slice:
+	case reflect.Slice, reflect.Array:
 		return enc.encodeSlice(b, ctx, v)
 	case reflect.Interface:
 		if v.IsNil() {
@@ -930,7 +930,7 @@ func willConvertToTableOrArrayTable(ctx encoderCtx, v reflect.Value) bool {
 		return willConvertToTableOrArrayTable(ctx, v.Elem())
 	}
 
-	if t.Kind() == reflect.Slice {
+	if t.Kind() == reflect.Slice || t.Kind() == reflect.Array {
 		if v.Len() == 0 {
 			// An empty slice should be a kv = [].
 			return false

vendor/github.com/pelletier/go-toml/v2/unmarshaler.go

@@ -1170,10 +1170,10 @@ func initAndDereferencePointer(v reflect.Value) reflect.Value {
 
 // Same as reflect.Value.FieldByIndex, but creates pointers if needed.
 func fieldByIndex(v reflect.Value, path []int) reflect.Value {
-	for i, x := range path {
+	for _, x := range path {
 		v = v.Field(x)
 
-		if i < len(path)-1 && v.Kind() == reflect.Ptr {
+		if v.Kind() == reflect.Ptr {
 			if v.IsNil() {
 				v.Set(reflect.New(v.Type().Elem()))
 			}