repo stringlengths 6 47 | file_url stringlengths 77 269 | file_path stringlengths 5 186 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 7
values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-07 08:35:43 2026-01-07 08:55:24 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/compat.go | vendor/github.com/bytedance/sonic/compat.go | // +build !amd64,!arm64 go1.25 !go1.17 arm64,!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 sonic
import (
`bytes`
`encoding/json`
`io`
`reflect`
`github.com/bytedance/sonic/option`
)
const apiKind = UseStdJSON
type frozenConfig struct {
Config
}
// Froze convert the Config to API
func (cfg Config) Froze() API {
api := &frozenConfig{Config: cfg}
return api
}
func (cfg frozenConfig) marshalOptions(val interface{}, prefix, indent string) ([]byte, error) {
w := bytes.NewBuffer([]byte{})
enc := json.NewEncoder(w)
enc.SetEscapeHTML(cfg.EscapeHTML)
enc.SetIndent(prefix, indent)
err := enc.Encode(val)
out := w.Bytes()
// json.Encoder always appends '\n' after encoding,
// which is not same with json.Marshal()
if len(out) > 0 && out[len(out)-1] == '\n' {
out = out[:len(out)-1]
}
return out, err
}
// Marshal is implemented by sonic
func (cfg frozenConfig) Marshal(val interface{}) ([]byte, error) {
if !cfg.EscapeHTML {
return cfg.marshalOptions(val, "", "")
}
return json.Marshal(val)
}
// MarshalToString is implemented by sonic
func (cfg frozenConfig) MarshalToString(val interface{}) (string, error) {
out, err := cfg.Marshal(val)
return string(out), err
}
// MarshalIndent is implemented by sonic
func (cfg frozenConfig) MarshalIndent(val interface{}, prefix, indent string) ([]byte, error) {
if !cfg.EscapeHTML {
return cfg.marshalOptions(val, prefix, indent)
}
return json.MarshalIndent(val, prefix, indent)
}
// UnmarshalFromString is implemented by sonic
func (cfg frozenConfig) UnmarshalFromString(buf string, val interface{}) error {
r := bytes.NewBufferString(buf)
dec := json.NewDecoder(r)
if cfg.UseNumber {
dec.UseNumber()
}
if cfg.DisallowUnknownFields {
dec.DisallowUnknownFields()
}
return dec.Decode(val)
}
// Unmarshal is implemented by sonic
func (cfg frozenConfig) Unmarshal(buf []byte, val interface{}) error {
return cfg.UnmarshalFromString(string(buf), val)
}
// NewEncoder is implemented by sonic
func (cfg frozenConfig) NewEncoder(writer io.Writer) Encoder {
enc := json.NewEncoder(writer)
if !cfg.EscapeHTML {
enc.SetEscapeHTML(cfg.EscapeHTML)
}
return enc
}
// NewDecoder is implemented by sonic
func (cfg frozenConfig) NewDecoder(reader io.Reader) Decoder {
dec := json.NewDecoder(reader)
if cfg.UseNumber {
dec.UseNumber()
}
if cfg.DisallowUnknownFields {
dec.DisallowUnknownFields()
}
return dec
}
// Valid is implemented by sonic
func (cfg frozenConfig) Valid(data []byte) bool {
return json.Valid(data)
}
// Pretouch compiles vt ahead-of-time to avoid JIT compilation on-the-fly, in
// order to reduce the first-hit latency at **amd64** Arch.
// Opts are the compile options, for example, "option.WithCompileRecursiveDepth" is
// a compile option to set the depth of recursive compile for the nested struct type.
// * This is the none implement for !amd64.
// It will be useful for someone who develop with !amd64 arch,like Mac M1.
func Pretouch(vt reflect.Type, opts ...option.CompileOption) error {
return nil
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/api.go | vendor/github.com/bytedance/sonic/api.go | /*
* 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 sonic
import (
`io`
`github.com/bytedance/sonic/ast`
`github.com/bytedance/sonic/internal/rt`
)
const (
// UseStdJSON indicates you are using fallback implementation (encoding/json)
UseStdJSON = iota
// UseSonicJSON indicates you are using real sonic implementation
UseSonicJSON
)
// APIKind is the kind of API, 0 is std json, 1 is sonic.
const APIKind = apiKind
// Config is a combination of sonic/encoder.Options and sonic/decoder.Options
type Config struct {
// EscapeHTML indicates encoder to escape all HTML characters
// after serializing into JSON (see https://pkg.go.dev/encoding/json#HTMLEscape).
// WARNING: This hurts performance A LOT, USE WITH CARE.
EscapeHTML bool
// SortMapKeys indicates encoder that the keys of a map needs to be sorted
// before serializing into JSON.
// WARNING: This hurts performance A LOT, USE WITH CARE.
SortMapKeys bool
// CompactMarshaler indicates encoder that the output JSON from json.Marshaler
// is always compact and needs no validation
CompactMarshaler bool
// NoQuoteTextMarshaler indicates encoder that the output text from encoding.TextMarshaler
// is always escaped string and needs no quoting
NoQuoteTextMarshaler bool
// NoNullSliceOrMap indicates encoder that all empty Array or Object are encoded as '[]' or '{}',
// instead of 'null'
NoNullSliceOrMap bool
// UseInt64 indicates decoder to unmarshal an integer into an interface{} as an
// int64 instead of as a float64.
UseInt64 bool
// UseNumber indicates decoder to unmarshal a number into an interface{} as a
// json.Number instead of as a float64.
UseNumber bool
// UseUnicodeErrors indicates decoder to return an error when encounter invalid
// UTF-8 escape sequences.
UseUnicodeErrors bool
// DisallowUnknownFields indicates decoder to return an error when the destination
// is a struct and the input contains object keys which do not match any
// non-ignored, exported fields in the destination.
DisallowUnknownFields bool
// CopyString indicates decoder to decode string values by copying instead of referring.
CopyString bool
// ValidateString indicates decoder and encoder to validate string values: decoder will return errors
// when unescaped control chars(\u0000-\u001f) in the string value of JSON.
ValidateString bool
// NoValidateJSONMarshaler indicates that the encoder should not validate the output string
// after encoding the JSONMarshaler to JSON.
NoValidateJSONMarshaler bool
// NoValidateJSONSkip indicates the decoder should not validate the JSON value when skipping it,
// such as unknown-fields, mismatched-type, redundant elements..
NoValidateJSONSkip bool
// NoEncoderNewline indicates that the encoder should not add a newline after every message
NoEncoderNewline bool
// Encode Infinity or Nan float into `null`, instead of returning an error.
EncodeNullForInfOrNan bool
}
var (
// ConfigDefault is the default config of APIs, aiming at efficiency and safety.
ConfigDefault = Config{}.Froze()
// ConfigStd is the standard config of APIs, aiming at being compatible with encoding/json.
ConfigStd = Config{
EscapeHTML : true,
SortMapKeys: true,
CompactMarshaler: true,
CopyString : true,
ValidateString : true,
}.Froze()
// ConfigFastest is the fastest config of APIs, aiming at speed.
ConfigFastest = Config{
NoQuoteTextMarshaler: true,
NoValidateJSONMarshaler: true,
NoValidateJSONSkip: true,
}.Froze()
)
// API is a binding of specific config.
// This interface is inspired by github.com/json-iterator/go,
// and has same behaviors under equivalent config.
type API interface {
// MarshalToString returns the JSON encoding string of v
MarshalToString(v interface{}) (string, error)
// Marshal returns the JSON encoding bytes of v.
Marshal(v interface{}) ([]byte, error)
// MarshalIndent returns the JSON encoding bytes with indent and prefix.
MarshalIndent(v interface{}, prefix, indent string) ([]byte, error)
// UnmarshalFromString parses the JSON-encoded bytes and stores the result in the value pointed to by v.
UnmarshalFromString(str string, v interface{}) error
// Unmarshal parses the JSON-encoded string and stores the result in the value pointed to by v.
Unmarshal(data []byte, v interface{}) error
// NewEncoder create a Encoder holding writer
NewEncoder(writer io.Writer) Encoder
// NewDecoder create a Decoder holding reader
NewDecoder(reader io.Reader) Decoder
// Valid validates the JSON-encoded bytes and reports if it is valid
Valid(data []byte) bool
}
// Encoder encodes JSON into io.Writer
type Encoder interface {
// Encode writes the JSON encoding of v to the stream, followed by a newline character.
Encode(val interface{}) error
// SetEscapeHTML specifies whether problematic HTML characters
// should be escaped inside JSON quoted strings.
// The default behavior NOT ESCAPE
SetEscapeHTML(on bool)
// SetIndent instructs the encoder to format each subsequent encoded value
// as if indented by the package-level function Indent(dst, src, prefix, indent).
// Calling SetIndent("", "") disables indentation
SetIndent(prefix, indent string)
}
// Decoder decodes JSON from io.Read
type Decoder interface {
// Decode reads the next JSON-encoded value from its input and stores it in the value pointed to by v.
Decode(val interface{}) error
// Buffered returns a reader of the data remaining in the Decoder's buffer.
// The reader is valid until the next call to Decode.
Buffered() io.Reader
// DisallowUnknownFields causes the Decoder to return an error when the destination is a struct
// and the input contains object keys which do not match any non-ignored, exported fields in the destination.
DisallowUnknownFields()
// More reports whether there is another element in the current array or object being parsed.
More() bool
// UseNumber causes the Decoder to unmarshal a number into an interface{} as a Number instead of as a float64.
UseNumber()
}
// Marshal returns the JSON encoding bytes of v.
func Marshal(val interface{}) ([]byte, error) {
return ConfigDefault.Marshal(val)
}
// MarshalIndent is like Marshal but applies Indent to format the output.
// Each JSON element in the output will begin on a new line beginning with prefix
// followed by one or more copies of indent according to the indentation nesting.
func MarshalIndent(v interface{}, prefix, indent string) ([]byte, error) {
return ConfigDefault.MarshalIndent(v, prefix, indent)
}
// MarshalString returns the JSON encoding string of v.
func MarshalString(val interface{}) (string, error) {
return ConfigDefault.MarshalToString(val)
}
// Unmarshal parses the JSON-encoded data and stores the result in the value pointed to by v.
// NOTICE: This API copies given buffer by default,
// if you want to pass JSON more efficiently, use UnmarshalString instead.
func Unmarshal(buf []byte, val interface{}) error {
return ConfigDefault.Unmarshal(buf, val)
}
// UnmarshalString is like Unmarshal, except buf is a string.
func UnmarshalString(buf string, val interface{}) error {
return ConfigDefault.UnmarshalFromString(buf, val)
}
// Get searches and locates the given path from src json,
// and returns a ast.Node representing the partially json.
//
// Each path arg must be integer or string:
// - Integer is target index(>=0), means searching current node as array.
// - String is target key, means searching current node as object.
//
//
// Notice: It expects the src json is **Well-formed** and **Immutable** when calling,
// otherwise it may return unexpected result.
// Considering memory safety, the returned JSON is **Copied** from the input
func Get(src []byte, path ...interface{}) (ast.Node, error) {
return GetCopyFromString(rt.Mem2Str(src), path...)
}
//GetWithOptions searches and locates the given path from src json,
// with specific options of ast.Searcher
func GetWithOptions(src []byte, opts ast.SearchOptions, path ...interface{}) (ast.Node, error) {
s := ast.NewSearcher(rt.Mem2Str(src))
s.SearchOptions = opts
return s.GetByPath(path...)
}
// GetFromString is same with Get except src is string.
//
// WARNING: The returned JSON is **Referenced** from the input.
// Caching or long-time holding the returned node may cause OOM.
// If your src is big, consider use GetFromStringCopy().
func GetFromString(src string, path ...interface{}) (ast.Node, error) {
return ast.NewSearcher(src).GetByPath(path...)
}
// GetCopyFromString is same with Get except src is string
func GetCopyFromString(src string, path ...interface{}) (ast.Node, error) {
return ast.NewSearcher(src).GetByPathCopy(path...)
}
// Valid reports whether data is a valid JSON encoding.
func Valid(data []byte) bool {
return ConfigDefault.Valid(data)
}
// Valid reports whether data is a valid JSON encoding.
func ValidString(data string) bool {
return ConfigDefault.Valid(rt.Str2Mem(data))
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/rawmessage.go | vendor/github.com/bytedance/sonic/rawmessage.go | /*
* Copyright 2024 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 sonic
import (
"errors"
)
// NoCopyRawMessage is a NOCOPY raw encoded JSON value.
// It implements [Marshaler] and [Unmarshaler] and can
// be used to delay JSON decoding or precompute a JSON encoding.
type NoCopyRawMessage []byte
// MarshalJSON returns m as the JSON encoding of m.
func (m NoCopyRawMessage) MarshalJSON() ([]byte, error) {
if m == nil {
return []byte("null"), nil
}
return m, nil
}
// UnmarshalJSON sets *m to a reference of data. NoCopy here!!!
func (m *NoCopyRawMessage) UnmarshalJSON(data []byte) error {
if m == nil {
return errors.New("sonic.NoCopyRawMessage: UnmarshalJSON on nil pointer")
}
*m = data
return nil
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/sonic.go | vendor/github.com/bytedance/sonic/sonic.go | //go:build (amd64 && go1.17 && !go1.25) || (arm64 && go1.20 && !go1.25)
// +build amd64,go1.17,!go1.25 arm64,go1.20,!go1.25
/*
* 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.
*/
//go:generate make
package sonic
import (
`io`
`reflect`
`github.com/bytedance/sonic/decoder`
`github.com/bytedance/sonic/encoder`
`github.com/bytedance/sonic/option`
`github.com/bytedance/sonic/internal/rt`
)
const apiKind = UseSonicJSON
type frozenConfig struct {
Config
encoderOpts encoder.Options
decoderOpts decoder.Options
}
// Froze convert the Config to API
func (cfg Config) Froze() API {
api := &frozenConfig{Config: cfg}
// configure encoder options:
if cfg.EscapeHTML {
api.encoderOpts |= encoder.EscapeHTML
}
if cfg.SortMapKeys {
api.encoderOpts |= encoder.SortMapKeys
}
if cfg.CompactMarshaler {
api.encoderOpts |= encoder.CompactMarshaler
}
if cfg.NoQuoteTextMarshaler {
api.encoderOpts |= encoder.NoQuoteTextMarshaler
}
if cfg.NoNullSliceOrMap {
api.encoderOpts |= encoder.NoNullSliceOrMap
}
if cfg.ValidateString {
api.encoderOpts |= encoder.ValidateString
}
if cfg.NoValidateJSONMarshaler {
api.encoderOpts |= encoder.NoValidateJSONMarshaler
}
if cfg.NoEncoderNewline {
api.encoderOpts |= encoder.NoEncoderNewline
}
if cfg.EncodeNullForInfOrNan {
api.encoderOpts |= encoder.EncodeNullForInfOrNan
}
// configure decoder options:
if cfg.NoValidateJSONSkip {
api.decoderOpts |= decoder.OptionNoValidateJSON
}
if cfg.UseInt64 {
api.decoderOpts |= decoder.OptionUseInt64
}
if cfg.UseNumber {
api.decoderOpts |= decoder.OptionUseNumber
}
if cfg.DisallowUnknownFields {
api.decoderOpts |= decoder.OptionDisableUnknown
}
if cfg.CopyString {
api.decoderOpts |= decoder.OptionCopyString
}
if cfg.ValidateString {
api.decoderOpts |= decoder.OptionValidateString
}
return api
}
// Marshal is implemented by sonic
func (cfg frozenConfig) Marshal(val interface{}) ([]byte, error) {
return encoder.Encode(val, cfg.encoderOpts)
}
// MarshalToString is implemented by sonic
func (cfg frozenConfig) MarshalToString(val interface{}) (string, error) {
buf, err := encoder.Encode(val, cfg.encoderOpts)
return rt.Mem2Str(buf), err
}
// MarshalIndent is implemented by sonic
func (cfg frozenConfig) MarshalIndent(val interface{}, prefix, indent string) ([]byte, error) {
return encoder.EncodeIndented(val, prefix, indent, cfg.encoderOpts)
}
// UnmarshalFromString is implemented by sonic
func (cfg frozenConfig) UnmarshalFromString(buf string, val interface{}) error {
dec := decoder.NewDecoder(buf)
dec.SetOptions(cfg.decoderOpts)
err := dec.Decode(val)
/* check for errors */
if err != nil {
return err
}
return dec.CheckTrailings()
}
// Unmarshal is implemented by sonic
func (cfg frozenConfig) Unmarshal(buf []byte, val interface{}) error {
return cfg.UnmarshalFromString(string(buf), val)
}
// NewEncoder is implemented by sonic
func (cfg frozenConfig) NewEncoder(writer io.Writer) Encoder {
enc := encoder.NewStreamEncoder(writer)
enc.Opts = cfg.encoderOpts
return enc
}
// NewDecoder is implemented by sonic
func (cfg frozenConfig) NewDecoder(reader io.Reader) Decoder {
dec := decoder.NewStreamDecoder(reader)
dec.SetOptions(cfg.decoderOpts)
return dec
}
// Valid is implemented by sonic
func (cfg frozenConfig) Valid(data []byte) bool {
ok, _ := encoder.Valid(data)
return ok
}
// Pretouch compiles vt ahead-of-time to avoid JIT compilation on-the-fly, in
// order to reduce the first-hit latency.
//
// Opts are the compile options, for example, "option.WithCompileRecursiveDepth" is
// a compile option to set the depth of recursive compile for the nested struct type.
func Pretouch(vt reflect.Type, opts ...option.CompileOption) error {
if err := encoder.Pretouch(vt, opts...); err != nil {
return err
}
if err := decoder.Pretouch(vt, opts...); err != nil {
return err
}
// to pretouch the corresponding pointer type as well
if vt.Kind() == reflect.Ptr {
vt = vt.Elem()
} else {
vt = reflect.PtrTo(vt)
}
if err := encoder.Pretouch(vt, opts...); err != nil {
return err
}
if err := decoder.Pretouch(vt, opts...); err != nil {
return err
}
return nil
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/pcdata.go | vendor/github.com/bytedance/sonic/loader/pcdata.go | /**
* Copyright 2023 ByteDance Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package loader
import (
`encoding/binary`
)
const (
_N_PCDATA = 4
_PCDATA_UnsafePoint = 0
_PCDATA_StackMapIndex = 1
_PCDATA_InlTreeIndex = 2
_PCDATA_ArgLiveIndex = 3
_PCDATA_INVALID_OFFSET = 0
)
const (
// PCDATA_UnsafePoint values.
PCDATA_UnsafePointSafe = -1 // Safe for async preemption
PCDATA_UnsafePointUnsafe = -2 // Unsafe for async preemption
// PCDATA_Restart1(2) apply on a sequence of instructions, within
// which if an async preemption happens, we should back off the PC
// to the start of the sequence when resume.
// We need two so we can distinguish the start/end of the sequence
// in case that two sequences are next to each other.
PCDATA_Restart1 = -3
PCDATA_Restart2 = -4
// Like PCDATA_RestartAtEntry, but back to function entry if async
// preempted.
PCDATA_RestartAtEntry = -5
_PCDATA_START_VAL = -1
)
var emptyByte byte
// Pcvalue is the program count corresponding to the value Val
// WARN: we use relative value here (to function entry)
type Pcvalue struct {
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
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 {
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
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/loader.go | vendor/github.com/bytedance/sonic/loader/loader.go | /**
* Copyright 2023 ByteDance Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package loader
import (
`unsafe`
)
// Function is a function pointer
type Function unsafe.Pointer
// Options used to load a module
type Options struct {
// NoPreempt is used to disable async preemption for this module
NoPreempt bool
}
// Loader is a helper used to load a module simply
type Loader struct {
Name string // module name
File string // file name
Options
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/funcdata_go120.go | vendor/github.com/bytedance/sonic/loader/funcdata_go120.go | //go:build go1.20 && !go1.21
// +build go1.20,!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/loader/internal/rt`
)
const (
_Magic uint32 = 0xFFFFFFF1
)
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
covctrs, ecovctrs uintptr
end, gcdata, gcbss uintptr
types, etypes uintptr
rodata uintptr
gofunc uintptr // go.func.* is actual funcinfo object in image
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 {
entryOff uint32 // 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
startLine int32 // line number of start of function (func keyword/TEXT directive)
funcID uint8 // set for certain special runtime functions
flag uint8
_ [1]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
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/wrapper.go | vendor/github.com/bytedance/sonic/loader/wrapper.go | /**
* Copyright 2023 ByteDance Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package loader
import (
`reflect`
`unsafe`
`github.com/bytedance/sonic/loader/internal/abi`
`github.com/bytedance/sonic/loader/internal/rt`
)
var _C_Redzone = []bool{false, false, false, false}
// CFunc is a function information for C func
type CFunc struct {
// C function name
Name string
// entry pc relative to entire text segment
EntryOff uint32
// function text size in bytes
TextSize uint32
// maximum stack depth of the function
MaxStack uintptr
// PC->SP delta lists of the function
Pcsp [][2]uint32
}
// GoC is the wrapper for Go calls to C
type GoC struct {
// CName is the name of corresponding C function
CName string
// CEntry points out where to store the entry address of corresponding C function.
// It won't be set if nil
CEntry *uintptr
// GoFunc is the POINTER of corresponding go stub function.
// It is used to generate Go-C ABI conversion wrapper and receive the wrapper's address
// eg. &func(a int, b int) int
// FOR
// int add(int a, int b)
// It won't be set if nil
GoFunc interface{}
}
// WrapGoC wraps C functions and loader it into Go stubs
func WrapGoC(text []byte, natives []CFunc, stubs []GoC, modulename string, filename string) {
funcs := make([]Func, len(natives))
// register C funcs
for i, f := range natives {
fn := Func{
Flag: FuncFlag_ASM,
EntryOff: f.EntryOff,
TextSize: f.TextSize,
Name: f.Name,
}
if len(f.Pcsp) != 0 {
fn.Pcsp = (*Pcdata)(unsafe.Pointer(&natives[i].Pcsp))
}
// NOTICE: always forbid async preempt
fn.PcUnsafePoint = &Pcdata{
{PC: f.TextSize, Val: PCDATA_UnsafePointUnsafe},
}
// NOTICE: always refer to first file
fn.Pcfile = &Pcdata{
{PC: f.TextSize, Val: 0},
}
// NOTICE: always refer to first line
fn.Pcline = &Pcdata{
{PC: f.TextSize, Val: 1},
}
// NOTICE: copystack need locals stackmap
fn.PcStackMapIndex = &Pcdata{
{PC: f.TextSize, Val: 0},
}
sm := rt.StackMapBuilder{}
sm.AddField(false)
fn.ArgsPointerMaps = sm.Build()
fn.LocalsPointerMaps = sm.Build()
funcs[i] = fn
}
rets := Load(text, funcs, modulename, []string{filename})
// got absolute entry address
native_entry := **(**uintptr)(unsafe.Pointer(&rets[0]))
// println("native_entry: ", native_entry)
wraps := make([]Func, 0, len(stubs))
wrapIds := make([]int, 0, len(stubs))
code := make([]byte, 0, len(wraps))
entryOff := uint32(0)
// register go wrappers
for i := range stubs {
for j := range natives {
if stubs[i].CName != natives[j].Name {
continue
}
// calculate corresponding C entry
pc := uintptr(native_entry + uintptr(natives[j].EntryOff))
if stubs[i].CEntry != nil {
*stubs[i].CEntry = pc
}
// no need to generate wrapper, continue next
if stubs[i].GoFunc == nil {
continue
}
// assemble wrapper codes
layout := abi.NewFunctionLayout(reflect.TypeOf(stubs[i].GoFunc).Elem())
frame := abi.NewFrame(&layout, _C_Redzone, true)
tcode := abi.CallC(pc, frame, natives[j].MaxStack)
code = append(code, tcode...)
size := uint32(len(tcode))
fn := Func{
Flag: FuncFlag_ASM,
ArgsSize: int32(layout.ArgSize()),
EntryOff: entryOff,
TextSize: size,
Name: stubs[i].CName + "_go",
}
// add check-stack and grow-stack texts' pcsp
fn.Pcsp = &Pcdata{
{PC: uint32(frame.StackCheckTextSize()), Val: 0},
{PC: size - uint32(frame.GrowStackTextSize()), Val: int32(frame.Size())},
{PC: size, Val: 0},
}
// NOTICE: always refer to first file
fn.Pcfile = &Pcdata{
{PC: size, Val: 0},
}
// NOTICE: always refer to first line
fn.Pcline = &Pcdata{
{PC: size, Val: 1},
}
// NOTICE: always forbid async preempt
fn.PcUnsafePoint = &Pcdata{
{PC: size, Val: PCDATA_UnsafePointUnsafe},
}
// register pointer stackmaps
fn.PcStackMapIndex = &Pcdata{
{PC: size, Val: 0},
}
fn.ArgsPointerMaps = frame.ArgPtrs()
fn.LocalsPointerMaps = frame.LocalPtrs()
entryOff += size
wraps = append(wraps, fn)
wrapIds = append(wrapIds, i)
}
}
gofuncs := Load(code, wraps, modulename+"/go", []string{filename+".go"})
// set go func value
for i := range gofuncs {
idx := wrapIds[i]
w := rt.UnpackEface(stubs[idx].GoFunc)
*(*Function)(w.Value) = gofuncs[i]
}
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/funcdata_go121.go | vendor/github.com/bytedance/sonic/loader/funcdata_go121.go | //go:build go1.21 && !go1.23
// +build go1.21,!go1.23
/*
* 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/loader/internal/rt`
)
const (
_Magic uint32 = 0xFFFFFFF1
)
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
covctrs, ecovctrs uintptr
end, gcdata, gcbss uintptr
types, etypes uintptr
rodata uintptr
gofunc uintptr // go.func.* is actual funcinfo object in image
textsectmap []textSection // see runtime/symtab.go: textAddr()
typelinks []int32 // offsets from types
itablinks []*rt.GoItab
ptab []ptabEntry
pluginpath string
pkghashes []modulehash
// This slice records the initializing tasks that need to be
// done to start up the program. It is built by the linker.
inittasks []unsafe.Pointer
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 {
entryOff uint32 // 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
startLine int32 // line number of start of function (func keyword/TEXT directive)
funcID uint8 // set for certain special runtime functions
flag uint8
_ [1]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
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/funcdata.go | vendor/github.com/bytedance/sonic/loader/funcdata.go | /**
* Copyright 2023 ByteDance Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package loader
import (
`encoding`
`encoding/binary`
`fmt`
`reflect`
`strings`
`sync`
`unsafe`
)
const (
_MinLC uint8 = 1
_PtrSize uint8 = 8
)
const (
_N_FUNCDATA = 8
_INVALID_FUNCDATA_OFFSET = ^uint32(0)
_FUNC_SIZE = unsafe.Sizeof(_func{})
_MINFUNC = 16 // minimum size for a function
_BUCKETSIZE = 256 * _MINFUNC
_SUBBUCKETS = 16
_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.
const (
_FUNCDATA_ArgsPointerMaps = 0
_FUNCDATA_LocalsPointerMaps = 1
_FUNCDATA_StackObjects = 2
_FUNCDATA_InlTree = 3
_FUNCDATA_OpenCodedDeferInfo = 4
_FUNCDATA_ArgInfo = 5
_FUNCDATA_ArgLiveInfo = 6
_FUNCDATA_WrapInfo = 7
// ArgsSizeUnknown is set in Func.argsize to mark all functions
// whose argument size is unknown (C vararg functions, and
// assembly code without an explicit specification).
// This value is generated by the compiler, assembler, or linker.
ArgsSizeUnknown = -0x80000000
)
// moduledata used to cache the funcdata and findfuncbucket of one module
var moduleCache = struct {
m map[*moduledata][]byte
sync.Mutex
}{
m: make(map[*moduledata][]byte),
}
// Func contains information about a function.
type Func struct {
ID uint8 // see runtime/symtab.go
Flag uint8 // see runtime/symtab.go
ArgsSize int32 // args byte size
EntryOff uint32 // start pc, offset to moduledata.text
TextSize uint32 // size of func text
DeferReturn uint32 // offset of start of a deferreturn call instruction from entry, if any.
FileIndex uint32 // index into filetab
Name string // name of function
// PC data
Pcsp *Pcdata // PC -> SP delta
Pcfile *Pcdata // PC -> file index
Pcline *Pcdata // PC -> line number
PcUnsafePoint *Pcdata // PC -> unsafe point, must be PCDATA_UnsafePointSafe or PCDATA_UnsafePointUnsafe
PcStackMapIndex *Pcdata // PC -> stack map index, relative to ArgsPointerMaps and LocalsPointerMaps
PcInlTreeIndex *Pcdata // PC -> inlining tree index, relative to InlTree
PcArgLiveIndex *Pcdata // PC -> arg live index, relative to ArgLiveInfo
// Func data, must implement encoding.BinaryMarshaler
ArgsPointerMaps encoding.BinaryMarshaler // concrete type: *StackMap
LocalsPointerMaps encoding.BinaryMarshaler // concrete type: *StackMap
StackObjects encoding.BinaryMarshaler
InlTree encoding.BinaryMarshaler
OpenCodedDeferInfo encoding.BinaryMarshaler
ArgInfo encoding.BinaryMarshaler
ArgLiveInfo encoding.BinaryMarshaler
WrapInfo encoding.BinaryMarshaler
}
func getOffsetOf(data interface{}, field string) uintptr {
t := reflect.TypeOf(data)
fv, ok := t.FieldByName(field)
if !ok {
panic(fmt.Sprintf("field %s not found in struct %s", field, t.Name()))
}
return fv.Offset
}
func rnd(v int64, r int64) int64 {
if r <= 0 {
return v
}
v += r - 1
c := v % r
if c < 0 {
c += r
}
v -= c
return v
}
var (
byteOrder binary.ByteOrder = binary.LittleEndian
)
func funcNameParts(name string) (string, string, string) {
i := strings.IndexByte(name, '[')
if i < 0 {
return name, "", ""
}
// TODO: use LastIndexByte once the bootstrap compiler is >= Go 1.5.
j := len(name) - 1
for j > i && name[j] != ']' {
j--
}
if j <= i {
return name, "", ""
}
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
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/mmap_windows.go | vendor/github.com/bytedance/sonic/loader/mmap_windows.go | //go:build windows
// +build windows
// build
/*
* 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 (
`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")
)
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
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/funcdata_latest.go | vendor/github.com/bytedance/sonic/loader/funcdata_latest.go | // go:build go1.18 && !go1.25
// +build go1.18,!go1.25
/*
* 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 (
`os`
`sort`
`unsafe`
`github.com/bytedance/sonic/loader/internal/rt`
)
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
}
type compilationUnit struct {
fileNames []string
}
func makeFtab(funcs []_func, maxpc 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*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.
ftab = append(ftab, funcTab{maxpc, 0})
return
}
// Pcln table format: [...]funcTab + [...]_Func
func makePclntable(size int64, startLocations []uint32, funcs []_func, maxpc 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.
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.
byteOrder.PutUint32(pclntab[offs:offs+4], maxpc)
// write func info table
for i := range funcs {
off := startLocations[i]
// write _func structure to pclntab
fb := rt.BytesFrom(unsafe.Pointer(&funcs[i]), 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++ {
// store the start s-th func of the bucket
var fb = findfuncbucket{idx: uint32(s)}
// find the last e-th func of the bucket
var pc = min + uint32((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++ {
// store the start func of the subbucket
fb._SUBBUCKETS[j] = byte(uint32(s) - fb.idx)
// find the s-th end func of the subbucket
pc = min + uint32(i*_BUCKETSIZE) + uint32((j+1)*_SUB_BUCKETSIZE)
for ; s < len(ftab)-1 && ftab[s+1].entry <= pc; s++ {}
}
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, 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))
cu = append(cu, filenames...)
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 segments
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))
// make pcdata table
// NOTICE: _func only use offset to index pcdata, thus no need mmap() pcdata
cuOff := cuOffs[0]
pctab, pcdataOffs, _funcs := makePctab(funcs, cuOff, 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
ftab, pclntSize, startLocations := makeFtab(_funcs, uint32(len(text)))
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.gofunc = uintptr(unsafe.Pointer(&cache[fstart]))
mod.findfunctab = uintptr(unsafe.Pointer(&cache[ffstart]))
// make pclnt table
pclntab := makePclntable(pclntSize, startLocations, _funcs, uint32(len(text)), pcdataOffs, funcdataOffs)
mod.pclntable = pclntab
// 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"),
}
// special 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
_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) {}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/register.go | vendor/github.com/bytedance/sonic/loader/register.go | // +build !bytedance_tango
/**
* Copyright 2024 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
*
* https://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 (
"sync/atomic"
"unsafe"
)
func registerModule(mod *moduledata) {
registerModuleLockFree(&lastmoduledatap, mod)
}
func registerModuleLockFree(tail **moduledata, mod *moduledata) {
for {
oldTail := loadModule(tail)
if casModule(tail, oldTail, mod) {
storeModule(&oldTail.next, mod)
break
}
}
}
func loadModule(p **moduledata) *moduledata {
return (*moduledata)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))
}
func storeModule(p **moduledata, value *moduledata) {
atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(value))
}
func casModule(p **moduledata, oldValue *moduledata, newValue *moduledata) bool {
return atomic.CompareAndSwapPointer(
(*unsafe.Pointer)(unsafe.Pointer(p)),
unsafe.Pointer(oldValue),
unsafe.Pointer(newValue),
)
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/register_tango.go | vendor/github.com/bytedance/sonic/loader/register_tango.go | // +build bytedance_tango
/**
* Copyright 2024 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
*
* https://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 (
"sync"
_ "unsafe"
)
//go:linkname pluginsMu plugin.pluginsMu
var pluginsMu sync.Mutex
func registerModule(mod *moduledata) {
pluginsMu.Lock()
defer pluginsMu.Unlock()
lastmoduledatap.next = mod
lastmoduledatap = mod
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/stubs.go | vendor/github.com/bytedance/sonic/loader/stubs.go | /**
* Copyright 2023 ByteDance Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package loader
import (
_ `unsafe`
)
//go:linkname lastmoduledatap runtime.lastmoduledatap
//goland:noinspection GoUnusedGlobalVariable
var lastmoduledatap *moduledata
//go:linkname moduledataverify1 runtime.moduledataverify1
func moduledataverify1(_ *moduledata)
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/mmap_unix.go | vendor/github.com/bytedance/sonic/loader/mmap_unix.go | //go:build !windows
// +build !windows
/**
* Copyright 2023 ByteDance Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package loader
import (
`syscall`
)
const (
_AP = syscall.MAP_ANON | syscall.MAP_PRIVATE
_RX = syscall.PROT_READ | syscall.PROT_EXEC
_RW = syscall.PROT_READ | syscall.PROT_WRITE
)
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)
}
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/funcdata_go123.go | vendor/github.com/bytedance/sonic/loader/funcdata_go123.go | //go:build go1.23 && !go1.25
// +build go1.23,!go1.25
/*
* 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/loader/internal/rt`
)
const (
_Magic uint32 = 0xFFFFFFF1
)
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
covctrs, ecovctrs uintptr
end, gcdata, gcbss uintptr
types, etypes uintptr
rodata uintptr
gofunc uintptr // go.func.* is actual funcinfo object in image
textsectmap []textSection // see runtime/symtab.go: textAddr()
typelinks []int32 // offsets from types
itablinks []*rt.GoItab
ptab []ptabEntry
pluginpath string
pkghashes []modulehash
// This slice records the initializing tasks that need to be
// done to start up the program. It is built by the linker.
inittasks []unsafe.Pointer
modulename string
modulehashes []modulehash
hasmain uint8 // 1 if module contains the main function, 0 otherwise
bad bool // module failed to load and should be ignored
gcdatamask, gcbssmask bitVector
typemap map[int32]*rt.GoType // offset to *_rtype in previous module
next *moduledata
}
type _func struct {
entryOff uint32 // 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
startLine int32 // line number of start of function (func keyword/TEXT directive)
funcID uint8 // set for certain special runtime functions
flag uint8
_ [1]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
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/funcdata_compat.go | vendor/github.com/bytedance/sonic/loader/funcdata_compat.go | //go:build !go1.17 || go1.25
// +build !go1.17 go1.25
/*
* 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 (
`os`
`unsafe`
`sort`
`github.com/bytedance/sonic/loader/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 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.
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.
ftab = append(ftab, funcTab{maxpc, 0})
return
}
// Pcln table format: [...]funcTab + [...]_Func
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
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.
byteOrder.PutUint64(pclntab[offs:offs+8], uint64(maxpc))
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++ {
// 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++ {
// store the start func of the subbucket
fb._SUBBUCKETS[j] = byte(uint32(s) - fb.idx)
// 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)
}
// 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, 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))
cu = append(cu, filenames...)
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 segments
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))
// make pcdata table
// NOTICE: _func only use offset to index pcdata, thus no need mmap() pcdata
cuOff := cuOffs[0]
pctab, pcdataOffs, _funcs := makePctab(funcs, addr, cuOff, 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
ftab, pclntSize, startLocations := makeFtab(_funcs, mod.maxpc)
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, mod.maxpc, pcdataOffs, funcdataAddr, funcdataOffs)
mod.pclntable = pclntab
// 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"),
}
// special 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
_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) {}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/loader_latest.go | vendor/github.com/bytedance/sonic/loader/loader_latest.go |
/*
* 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/loader/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) {
ids := make([]string, len(funcs))
for i, f := range funcs {
ids[i] = f.Name
}
// 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, s := range ids {
for _, f := range funcs {
if f.Name == s {
m := uintptr(mod.text + uintptr(f.EntryOff))
out[i] = Function(&m)
}
}
}
return
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/funcdata_go118.go | vendor/github.com/bytedance/sonic/loader/funcdata_go118.go | // go:build go1.18 && !go1.20
//go:build go1.18 && !go1.20
// +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 (
`github.com/bytedance/sonic/loader/internal/rt`
)
const (
_Magic uint32 = 0xfffffff0
)
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
rodata uintptr
gofunc uintptr // go.func.* is actual funcinfo object in image
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 {
entryOff uint32 // 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
flag uint8
_ [1]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
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/funcdata_go117.go | vendor/github.com/bytedance/sonic/loader/funcdata_go117.go | //go:build go1.17 && !go1.18
// +build go1.17,!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 (
`os`
`unsafe`
`sort`
`github.com/bytedance/sonic/loader/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 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.
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.
ftab = append(ftab, funcTab{maxpc, 0})
return
}
// Pcln table format: [...]funcTab + [...]_Func
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
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.
byteOrder.PutUint64(pclntab[offs:offs+8], uint64(maxpc))
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++ {
// 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++ {
// store the start func of the subbucket
fb._SUBBUCKETS[j] = byte(uint32(s) - fb.idx)
// 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)
}
// 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, 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))
cu = append(cu, filenames...)
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 segments
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))
// make pcdata table
// NOTICE: _func only use offset to index pcdata, thus no need mmap() pcdata
cuOff := cuOffs[0]
pctab, pcdataOffs, _funcs := makePctab(funcs, addr, cuOff, 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
ftab, pclntSize, startLocations := makeFtab(_funcs, mod.maxpc)
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, mod.maxpc, pcdataOffs, funcdataAddr, funcdataOffs)
mod.pclntable = pclntab
// 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"),
}
// special 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
_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) {}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/internal/iasm/expr/ops.go | vendor/github.com/bytedance/sonic/loader/internal/iasm/expr/ops.go | //
// Copyright 2024 CloudWeGo Authors
//
// 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 expr
import (
"fmt"
)
func idiv(v int64, d int64) (int64, error) {
if d != 0 {
return v / d, nil
} else {
return 0, newRuntimeError("division by zero")
}
}
func imod(v int64, d int64) (int64, error) {
if d != 0 {
return v % d, nil
} else {
return 0, newRuntimeError("division by zero")
}
}
func ipow(v int64, e int64) (int64, error) {
mul := v
ret := int64(1)
/* value must be 0 or positive */
if v < 0 {
return 0, newRuntimeError(fmt.Sprintf("negative base value: %d", v))
}
/* exponent must be non-negative */
if e < 0 {
return 0, newRuntimeError(fmt.Sprintf("negative exponent: %d", e))
}
/* fast power first round */
if (e & 1) != 0 {
ret *= mul
}
/* fast power remaining rounds */
for e >>= 1; e != 0; e >>= 1 {
if mul *= mul; (e & 1) != 0 {
ret *= mul
}
}
/* all done */
return ret, nil
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/internal/iasm/expr/parser.go | vendor/github.com/bytedance/sonic/loader/internal/iasm/expr/parser.go | //
// Copyright 2024 CloudWeGo Authors
//
// 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 expr
import (
"strconv"
"unicode"
"unsafe"
)
type _TokenKind uint8
const (
_T_end _TokenKind = iota + 1
_T_int
_T_punc
_T_name
)
const (
_OP2 = 0x80
_POW = _OP2 | '*'
_SHL = _OP2 | '<'
_SHR = _OP2 | '>'
)
type _Slice struct {
p unsafe.Pointer
n int
c int
}
type _Token struct {
pos int
ptr *rune
u64 uint64
tag _TokenKind
}
func (self _Token) str() (v string) {
return string(self.rbuf())
}
func (self _Token) rbuf() (v []rune) {
(*_Slice)(unsafe.Pointer(&v)).c = int(self.u64)
(*_Slice)(unsafe.Pointer(&v)).n = int(self.u64)
(*_Slice)(unsafe.Pointer(&v)).p = unsafe.Pointer(self.ptr)
return
}
func tokenEnd(p int) _Token {
return _Token{
pos: p,
tag: _T_end,
}
}
func tokenInt(p int, v uint64) _Token {
return _Token{
pos: p,
u64: v,
tag: _T_int,
}
}
func tokenPunc(p int, v rune) _Token {
return _Token{
pos: p,
tag: _T_punc,
u64: uint64(v),
}
}
func tokenName(p int, v []rune) _Token {
return _Token{
pos: p,
ptr: &v[0],
tag: _T_name,
u64: uint64(len(v)),
}
}
// Repository represents a repository of Term's.
type Repository interface {
Get(name string) (Term, error)
}
// Parser parses an expression string to it's AST representation.
type Parser struct {
pos int
src []rune
}
var binaryOps = [...]func(*Expr, *Expr) *Expr{
'+': (*Expr).Add,
'-': (*Expr).Sub,
'*': (*Expr).Mul,
'/': (*Expr).Div,
'%': (*Expr).Mod,
'&': (*Expr).And,
'^': (*Expr).Xor,
'|': (*Expr).Or,
_SHL: (*Expr).Shl,
_SHR: (*Expr).Shr,
_POW: (*Expr).Pow,
}
var precedence = [...]map[int]bool{
{_SHL: true, _SHR: true},
{'|': true},
{'^': true},
{'&': true},
{'+': true, '-': true},
{'*': true, '/': true, '%': true},
{_POW: true},
}
func (self *Parser) ch() rune {
return self.src[self.pos]
}
func (self *Parser) eof() bool {
return self.pos >= len(self.src)
}
func (self *Parser) rch() (v rune) {
v, self.pos = self.src[self.pos], self.pos+1
return
}
func (self *Parser) hex(ss []rune) bool {
if len(ss) == 1 && ss[0] == '0' {
return unicode.ToLower(self.ch()) == 'x'
} else if len(ss) <= 1 || unicode.ToLower(ss[1]) != 'x' {
return unicode.IsDigit(self.ch())
} else {
return ishexdigit(self.ch())
}
}
func (self *Parser) int(p int, ss []rune) (_Token, error) {
var err error
var val uint64
/* find all the digits */
for !self.eof() && self.hex(ss) {
ss = append(ss, self.rch())
}
/* parse the value */
if val, err = strconv.ParseUint(string(ss), 0, 64); err != nil {
return _Token{}, err
} else {
return tokenInt(p, val), nil
}
}
func (self *Parser) name(p int, ss []rune) _Token {
for !self.eof() && isident(self.ch()) {
ss = append(ss, self.rch())
}
return tokenName(p, ss)
}
func (self *Parser) read(p int, ch rune) (_Token, error) {
if isdigit(ch) {
return self.int(p, []rune{ch})
} else if isident0(ch) {
return self.name(p, []rune{ch}), nil
} else if isop2ch(ch) && !self.eof() && self.ch() == ch {
return tokenPunc(p, _OP2|self.rch()), nil
} else if isop1ch(ch) {
return tokenPunc(p, ch), nil
} else {
return _Token{}, newSyntaxError(self.pos, "invalid character "+strconv.QuoteRuneToASCII(ch))
}
}
func (self *Parser) next() (_Token, error) {
for {
var p int
var c rune
/* check for EOF */
if self.eof() {
return tokenEnd(self.pos), nil
}
/* read the next char */
p = self.pos
c = self.rch()
/* parse the token if not a space */
if !unicode.IsSpace(c) {
return self.read(p, c)
}
}
}
func (self *Parser) grab(tk _Token, repo Repository) (*Expr, error) {
if repo == nil {
return nil, newSyntaxError(tk.pos, "unresolved symbol: "+tk.str())
} else if term, err := repo.Get(tk.str()); err != nil {
return nil, err
} else {
return Ref(term), nil
}
}
func (self *Parser) nest(nest int, repo Repository) (*Expr, error) {
var err error
var ret *Expr
var ntk _Token
/* evaluate the nested expression */
if ret, err = self.expr(0, nest+1, repo); err != nil {
return nil, err
}
/* must follows with a ')' */
if ntk, err = self.next(); err != nil {
return nil, err
} else if ntk.tag != _T_punc || ntk.u64 != ')' {
return nil, newSyntaxError(ntk.pos, "')' expected")
} else {
return ret, nil
}
}
func (self *Parser) unit(nest int, repo Repository) (*Expr, error) {
if tk, err := self.next(); err != nil {
return nil, err
} else if tk.tag == _T_int {
return Int(int64(tk.u64)), nil
} else if tk.tag == _T_name {
return self.grab(tk, repo)
} else if tk.tag == _T_punc && tk.u64 == '(' {
return self.nest(nest, repo)
} else if tk.tag == _T_punc && tk.u64 == '+' {
return self.unit(nest, repo)
} else if tk.tag == _T_punc && tk.u64 == '-' {
return neg2(self.unit(nest, repo))
} else if tk.tag == _T_punc && tk.u64 == '~' {
return not2(self.unit(nest, repo))
} else {
return nil, newSyntaxError(tk.pos, "integer, unary operator or nested expression expected")
}
}
func (self *Parser) term(prec int, nest int, repo Repository) (*Expr, error) {
var err error
var val *Expr
/* parse the LHS operand */
if val, err = self.expr(prec+1, nest, repo); err != nil {
return nil, err
}
/* parse all the operators of the same precedence */
for {
var op int
var rv *Expr
var tk _Token
/* peek the next token */
pp := self.pos
tk, err = self.next()
/* check for errors */
if err != nil {
return nil, err
}
/* encountered EOF */
if tk.tag == _T_end {
return val, nil
}
/* must be an operator */
if tk.tag != _T_punc {
return nil, newSyntaxError(tk.pos, "operators expected")
}
/* check for the operator precedence */
if op = int(tk.u64); !precedence[prec][op] {
self.pos = pp
return val, nil
}
/* evaluate the RHS operand, and combine the value */
if rv, err = self.expr(prec+1, nest, repo); err != nil {
return nil, err
} else {
val = binaryOps[op](val, rv)
}
}
}
func (self *Parser) expr(prec int, nest int, repo Repository) (*Expr, error) {
if prec >= len(precedence) {
return self.unit(nest, repo)
} else {
return self.term(prec, nest, repo)
}
}
// Parse parses the expression, and returns it's AST tree.
func (self *Parser) Parse(repo Repository) (*Expr, error) {
return self.expr(0, 0, repo)
}
// SetSource resets the expression parser and sets the expression source.
func (self *Parser) SetSource(src string) *Parser {
self.pos = 0
self.src = []rune(src)
return self
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/internal/iasm/expr/errors.go | vendor/github.com/bytedance/sonic/loader/internal/iasm/expr/errors.go | //
// Copyright 2024 CloudWeGo Authors
//
// 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 expr
import (
"fmt"
)
// SyntaxError represents a syntax error in the expression.
type SyntaxError struct {
Pos int
Reason string
}
func newSyntaxError(pos int, reason string) *SyntaxError {
return &SyntaxError{
Pos: pos,
Reason: reason,
}
}
func (self *SyntaxError) Error() string {
return fmt.Sprintf("Syntax error at position %d: %s", self.Pos, self.Reason)
}
// RuntimeError is an error which would occure at run time.
type RuntimeError struct {
Reason string
}
func newRuntimeError(reason string) *RuntimeError {
return &RuntimeError{
Reason: reason,
}
}
func (self *RuntimeError) Error() string {
return "Runtime error: " + self.Reason
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/internal/iasm/expr/utils.go | vendor/github.com/bytedance/sonic/loader/internal/iasm/expr/utils.go | //
// Copyright 2024 CloudWeGo Authors
//
// 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 expr
var op1ch = [...]bool{
'+': true,
'-': true,
'*': true,
'/': true,
'%': true,
'&': true,
'|': true,
'^': true,
'~': true,
'(': true,
')': true,
}
var op2ch = [...]bool{
'*': true,
'<': true,
'>': true,
}
func neg2(v *Expr, err error) (*Expr, error) {
if err != nil {
return nil, err
} else {
return v.Neg(), nil
}
}
func not2(v *Expr, err error) (*Expr, error) {
if err != nil {
return nil, err
} else {
return v.Not(), nil
}
}
func isop1ch(ch rune) bool {
return ch >= 0 && int(ch) < len(op1ch) && op1ch[ch]
}
func isop2ch(ch rune) bool {
return ch >= 0 && int(ch) < len(op2ch) && op2ch[ch]
}
func isdigit(ch rune) bool {
return ch >= '0' && ch <= '9'
}
func isident(ch rune) bool {
return isdigit(ch) || isident0(ch)
}
func isident0(ch rune) bool {
return (ch == '_') || (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')
}
func ishexdigit(ch rune) bool {
return isdigit(ch) || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F')
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/internal/iasm/expr/term.go | vendor/github.com/bytedance/sonic/loader/internal/iasm/expr/term.go | //
// Copyright 2024 CloudWeGo Authors
//
// 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 expr
// Term represents a value that can Evaluate() into an integer.
type Term interface {
Free()
Evaluate() (int64, error)
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/internal/iasm/expr/ast.go | vendor/github.com/bytedance/sonic/loader/internal/iasm/expr/ast.go | //
// Copyright 2024 CloudWeGo Authors
//
// 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 expr
import (
"fmt"
)
// Type is tyep expression type.
type Type int
const (
// CONST indicates that the expression is a constant.
CONST Type = iota
// TERM indicates that the expression is a Term reference.
TERM
// EXPR indicates that the expression is a unary or binary expression.
EXPR
)
var typeNames = map[Type]string{
EXPR: "Expr",
TERM: "Term",
CONST: "Const",
}
// String returns the string representation of a Type.
func (self Type) String() string {
if v, ok := typeNames[self]; ok {
return v
} else {
return fmt.Sprintf("expr.Type(%d)", self)
}
}
// Operator represents an operation to perform when Type is EXPR.
type Operator uint8
const (
// ADD performs "Add Expr.Left and Expr.Right".
ADD Operator = iota
// SUB performs "Subtract Expr.Left by Expr.Right".
SUB
// MUL performs "Multiply Expr.Left by Expr.Right".
MUL
// DIV performs "Divide Expr.Left by Expr.Right".
DIV
// MOD performs "Modulo Expr.Left by Expr.Right".
MOD
// AND performs "Bitwise AND Expr.Left and Expr.Right".
AND
// OR performs "Bitwise OR Expr.Left and Expr.Right".
OR
// XOR performs "Bitwise XOR Expr.Left and Expr.Right".
XOR
// SHL performs "Bitwise Shift Expr.Left to the Left by Expr.Right Bits".
SHL
// SHR performs "Bitwise Shift Expr.Left to the Right by Expr.Right Bits".
SHR
// POW performs "Raise Expr.Left to the power of Expr.Right"
POW
// NOT performs "Bitwise Invert Expr.Left".
NOT
// NEG performs "Negate Expr.Left".
NEG
)
var operatorNames = map[Operator]string{
ADD: "Add",
SUB: "Subtract",
MUL: "Multiply",
DIV: "Divide",
MOD: "Modulo",
AND: "And",
OR: "Or",
XOR: "ExclusiveOr",
SHL: "ShiftLeft",
SHR: "ShiftRight",
POW: "Power",
NOT: "Invert",
NEG: "Negate",
}
// String returns the string representation of a Type.
func (self Operator) String() string {
if v, ok := operatorNames[self]; ok {
return v
} else {
return fmt.Sprintf("expr.Operator(%d)", self)
}
}
// Expr represents an expression node.
type Expr struct {
Type Type
Term Term
Op Operator
Left *Expr
Right *Expr
Const int64
}
// Ref creates an expression from a Term.
func Ref(t Term) (p *Expr) {
p = newExpression()
p.Term = t
p.Type = TERM
return
}
// Int creates an expression from an integer.
func Int(v int64) (p *Expr) {
p = newExpression()
p.Type = CONST
p.Const = v
return
}
func (self *Expr) clear() {
if self.Term != nil {
self.Term.Free()
}
if self.Left != nil {
self.Left.Free()
}
if self.Right != nil {
self.Right.Free()
}
}
// Free returns the Expr into pool.
// Any operation performed after Free is undefined behavior.
func (self *Expr) Free() {
self.clear()
freeExpression(self)
}
// Evaluate evaluates the expression into an integer.
// It also implements the Term interface.
func (self *Expr) Evaluate() (int64, error) {
switch self.Type {
case EXPR:
return self.eval()
case TERM:
return self.Term.Evaluate()
case CONST:
return self.Const, nil
default:
panic("invalid expression type: " + self.Type.String())
}
}
/** Expression Combinator **/
func combine(a *Expr, op Operator, b *Expr) (r *Expr) {
r = newExpression()
r.Op = op
r.Type = EXPR
r.Left = a
r.Right = b
return
}
func (self *Expr) Add(v *Expr) *Expr { return combine(self, ADD, v) }
func (self *Expr) Sub(v *Expr) *Expr { return combine(self, SUB, v) }
func (self *Expr) Mul(v *Expr) *Expr { return combine(self, MUL, v) }
func (self *Expr) Div(v *Expr) *Expr { return combine(self, DIV, v) }
func (self *Expr) Mod(v *Expr) *Expr { return combine(self, MOD, v) }
func (self *Expr) And(v *Expr) *Expr { return combine(self, AND, v) }
func (self *Expr) Or(v *Expr) *Expr { return combine(self, OR, v) }
func (self *Expr) Xor(v *Expr) *Expr { return combine(self, XOR, v) }
func (self *Expr) Shl(v *Expr) *Expr { return combine(self, SHL, v) }
func (self *Expr) Shr(v *Expr) *Expr { return combine(self, SHR, v) }
func (self *Expr) Pow(v *Expr) *Expr { return combine(self, POW, v) }
func (self *Expr) Not() *Expr { return combine(self, NOT, nil) }
func (self *Expr) Neg() *Expr { return combine(self, NEG, nil) }
/** Expression Evaluator **/
var binaryEvaluators = [256]func(int64, int64) (int64, error){
ADD: func(a, b int64) (int64, error) { return a + b, nil },
SUB: func(a, b int64) (int64, error) { return a - b, nil },
MUL: func(a, b int64) (int64, error) { return a * b, nil },
DIV: idiv,
MOD: imod,
AND: func(a, b int64) (int64, error) { return a & b, nil },
OR: func(a, b int64) (int64, error) { return a | b, nil },
XOR: func(a, b int64) (int64, error) { return a ^ b, nil },
SHL: func(a, b int64) (int64, error) { return a << b, nil },
SHR: func(a, b int64) (int64, error) { return a >> b, nil },
POW: ipow,
}
func (self *Expr) eval() (int64, error) {
var lhs int64
var rhs int64
var err error
var vfn func(int64, int64) (int64, error)
/* evaluate LHS */
if lhs, err = self.Left.Evaluate(); err != nil {
return 0, err
}
/* check for unary operators */
switch self.Op {
case NOT:
return self.unaryNot(lhs)
case NEG:
return self.unaryNeg(lhs)
}
/* check for operators */
if vfn = binaryEvaluators[self.Op]; vfn == nil {
panic("invalid operator: " + self.Op.String())
}
/* must be a binary expression */
if self.Right == nil {
panic("operator " + self.Op.String() + " is a binary operator")
}
/* evaluate RHS, and call the operator */
if rhs, err = self.Right.Evaluate(); err != nil {
return 0, err
} else {
return vfn(lhs, rhs)
}
}
func (self *Expr) unaryNot(v int64) (int64, error) {
if self.Right == nil {
return ^v, nil
} else {
panic("operator Invert is an unary operator")
}
}
func (self *Expr) unaryNeg(v int64) (int64, error) {
if self.Right == nil {
return -v, nil
} else {
panic("operator Negate is an unary operator")
}
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/internal/iasm/expr/pools.go | vendor/github.com/bytedance/sonic/loader/internal/iasm/expr/pools.go | //
// Copyright 2024 CloudWeGo Authors
//
// 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 expr
import (
"sync"
)
var (
expressionPool sync.Pool
)
func newExpression() *Expr {
if v := expressionPool.Get(); v == nil {
return new(Expr)
} else {
return resetExpression(v.(*Expr))
}
}
func freeExpression(p *Expr) {
expressionPool.Put(p)
}
func resetExpression(p *Expr) *Expr {
*p = Expr{}
return p
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/internal/iasm/x86_64/arch.go | vendor/github.com/bytedance/sonic/loader/internal/iasm/x86_64/arch.go | //
// Copyright 2024 CloudWeGo Authors
//
// 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 x86_64
import (
"fmt"
)
// ISA represents an extension to x86-64 instruction set.
type ISA uint64
const (
ISA_CPUID ISA = 1 << iota
ISA_RDTSC
ISA_RDTSCP
ISA_CMOV
ISA_MOVBE
ISA_POPCNT
ISA_LZCNT
ISA_TBM
ISA_BMI
ISA_BMI2
ISA_ADX
ISA_MMX
ISA_MMX_PLUS
ISA_FEMMS
ISA_3DNOW
ISA_3DNOW_PLUS
ISA_SSE
ISA_SSE2
ISA_SSE3
ISA_SSSE3
ISA_SSE4A
ISA_SSE4_1
ISA_SSE4_2
ISA_FMA3
ISA_FMA4
ISA_XOP
ISA_F16C
ISA_AVX
ISA_AVX2
ISA_AVX512F
ISA_AVX512BW
ISA_AVX512DQ
ISA_AVX512VL
ISA_AVX512PF
ISA_AVX512ER
ISA_AVX512CD
ISA_AVX512VBMI
ISA_AVX512IFMA
ISA_AVX512VPOPCNTDQ
ISA_AVX512_4VNNIW
ISA_AVX512_4FMAPS
ISA_PREFETCH
ISA_PREFETCHW
ISA_PREFETCHWT1
ISA_CLFLUSH
ISA_CLFLUSHOPT
ISA_CLWB
ISA_CLZERO
ISA_RDRAND
ISA_RDSEED
ISA_PCLMULQDQ
ISA_AES
ISA_SHA
ISA_MONITOR
ISA_MONITORX
ISA_ALL = ^ISA(0)
)
var _ISA_NAMES = map[ISA]string{
ISA_CPUID: "CPUID",
ISA_RDTSC: "RDTSC",
ISA_RDTSCP: "RDTSCP",
ISA_CMOV: "CMOV",
ISA_MOVBE: "MOVBE",
ISA_POPCNT: "POPCNT",
ISA_LZCNT: "LZCNT",
ISA_TBM: "TBM",
ISA_BMI: "BMI",
ISA_BMI2: "BMI2",
ISA_ADX: "ADX",
ISA_MMX: "MMX",
ISA_MMX_PLUS: "MMX+",
ISA_FEMMS: "FEMMS",
ISA_3DNOW: "3dnow!",
ISA_3DNOW_PLUS: "3dnow!+",
ISA_SSE: "SSE",
ISA_SSE2: "SSE2",
ISA_SSE3: "SSE3",
ISA_SSSE3: "SSSE3",
ISA_SSE4A: "SSE4A",
ISA_SSE4_1: "SSE4.1",
ISA_SSE4_2: "SSE4.2",
ISA_FMA3: "FMA3",
ISA_FMA4: "FMA4",
ISA_XOP: "XOP",
ISA_F16C: "F16C",
ISA_AVX: "AVX",
ISA_AVX2: "AVX2",
ISA_AVX512F: "AVX512F",
ISA_AVX512BW: "AVX512BW",
ISA_AVX512DQ: "AVX512DQ",
ISA_AVX512VL: "AVX512VL",
ISA_AVX512PF: "AVX512PF",
ISA_AVX512ER: "AVX512ER",
ISA_AVX512CD: "AVX512CD",
ISA_AVX512VBMI: "AVX512VBMI",
ISA_AVX512IFMA: "AVX512IFMA",
ISA_AVX512VPOPCNTDQ: "AVX512VPOPCNTDQ",
ISA_AVX512_4VNNIW: "AVX512_4VNNIW",
ISA_AVX512_4FMAPS: "AVX512_4FMAPS",
ISA_PREFETCH: "PREFETCH",
ISA_PREFETCHW: "PREFETCHW",
ISA_PREFETCHWT1: "PREFETCHWT1",
ISA_CLFLUSH: "CLFLUSH",
ISA_CLFLUSHOPT: "CLFLUSHOPT",
ISA_CLWB: "CLWB",
ISA_CLZERO: "CLZERO",
ISA_RDRAND: "RDRAND",
ISA_RDSEED: "RDSEED",
ISA_PCLMULQDQ: "PCLMULQDQ",
ISA_AES: "AES",
ISA_SHA: "SHA",
ISA_MONITOR: "MONITOR",
ISA_MONITORX: "MONITORX",
}
var _ISA_MAPPING = map[string]ISA{
"CPUID": ISA_CPUID,
"RDTSC": ISA_RDTSC,
"RDTSCP": ISA_RDTSCP,
"CMOV": ISA_CMOV,
"MOVBE": ISA_MOVBE,
"POPCNT": ISA_POPCNT,
"LZCNT": ISA_LZCNT,
"TBM": ISA_TBM,
"BMI": ISA_BMI,
"BMI2": ISA_BMI2,
"ADX": ISA_ADX,
"MMX": ISA_MMX,
"MMX+": ISA_MMX_PLUS,
"FEMMS": ISA_FEMMS,
"3dnow!": ISA_3DNOW,
"3dnow!+": ISA_3DNOW_PLUS,
"SSE": ISA_SSE,
"SSE2": ISA_SSE2,
"SSE3": ISA_SSE3,
"SSSE3": ISA_SSSE3,
"SSE4A": ISA_SSE4A,
"SSE4.1": ISA_SSE4_1,
"SSE4.2": ISA_SSE4_2,
"FMA3": ISA_FMA3,
"FMA4": ISA_FMA4,
"XOP": ISA_XOP,
"F16C": ISA_F16C,
"AVX": ISA_AVX,
"AVX2": ISA_AVX2,
"AVX512F": ISA_AVX512F,
"AVX512BW": ISA_AVX512BW,
"AVX512DQ": ISA_AVX512DQ,
"AVX512VL": ISA_AVX512VL,
"AVX512PF": ISA_AVX512PF,
"AVX512ER": ISA_AVX512ER,
"AVX512CD": ISA_AVX512CD,
"AVX512VBMI": ISA_AVX512VBMI,
"AVX512IFMA": ISA_AVX512IFMA,
"AVX512VPOPCNTDQ": ISA_AVX512VPOPCNTDQ,
"AVX512_4VNNIW": ISA_AVX512_4VNNIW,
"AVX512_4FMAPS": ISA_AVX512_4FMAPS,
"PREFETCH": ISA_PREFETCH,
"PREFETCHW": ISA_PREFETCHW,
"PREFETCHWT1": ISA_PREFETCHWT1,
"CLFLUSH": ISA_CLFLUSH,
"CLFLUSHOPT": ISA_CLFLUSHOPT,
"CLWB": ISA_CLWB,
"CLZERO": ISA_CLZERO,
"RDRAND": ISA_RDRAND,
"RDSEED": ISA_RDSEED,
"PCLMULQDQ": ISA_PCLMULQDQ,
"AES": ISA_AES,
"SHA": ISA_SHA,
"MONITOR": ISA_MONITOR,
"MONITORX": ISA_MONITORX,
}
func (self ISA) String() string {
if v, ok := _ISA_NAMES[self]; ok {
return v
} else {
return fmt.Sprintf("(invalid: %#x)", uint64(self))
}
}
// ParseISA parses name into ISA, it will panic if the name is invalid.
func ParseISA(name string) ISA {
if v, ok := _ISA_MAPPING[name]; ok {
return v
} else {
panic("invalid ISA name: " + name)
}
}
// Arch represents the x86_64 architecture.
type Arch struct {
isa ISA
}
// DefaultArch is the default architecture with all ISA enabled.
var DefaultArch = CreateArch()
// CreateArch creates a new Arch with all ISA enabled.
func CreateArch() *Arch {
return new(Arch).EnableISA(ISA_ALL)
}
// HasISA checks if a particular ISA was enabled.
func (self *Arch) HasISA(isa ISA) bool {
return (self.isa & isa) != 0
}
// EnableISA enables a particular ISA.
func (self *Arch) EnableISA(isa ISA) *Arch {
self.isa |= isa
return self
}
// DisableISA disables a particular ISA.
func (self *Arch) DisableISA(isa ISA) *Arch {
self.isa &^= isa
return self
}
// CreateProgram creates a new empty program.
func (self *Arch) CreateProgram() *Program {
return newProgram(self)
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/internal/iasm/x86_64/utils.go | vendor/github.com/bytedance/sonic/loader/internal/iasm/x86_64/utils.go | //
// Copyright 2024 CloudWeGo Authors
//
// 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 x86_64
import (
"encoding/binary"
"errors"
"reflect"
"strconv"
"unicode/utf8"
"unsafe"
)
const (
_CC_digit = 1 << iota
_CC_ident
_CC_ident0
_CC_number
)
func ispow2(v uint64) bool {
return (v & (v - 1)) == 0
}
func isdigit(cc rune) bool {
return '0' <= cc && cc <= '9'
}
func isalpha(cc rune) bool {
return (cc >= 'a' && cc <= 'z') || (cc >= 'A' && cc <= 'Z')
}
func isident(cc rune) bool {
return cc == '_' || isalpha(cc) || isdigit(cc)
}
func isident0(cc rune) bool {
return cc == '_' || isalpha(cc)
}
func isnumber(cc rune) bool {
return (cc == 'b' || cc == 'B') ||
(cc == 'o' || cc == 'O') ||
(cc == 'x' || cc == 'X') ||
(cc >= '0' && cc <= '9') ||
(cc >= 'a' && cc <= 'f') ||
(cc >= 'A' && cc <= 'F')
}
func align(v int, n int) int {
return (((v - 1) >> n) + 1) << n
}
func append8(m *[]byte, v byte) {
*m = append(*m, v)
}
func append16(m *[]byte, v uint16) {
p := len(*m)
*m = append(*m, 0, 0)
binary.LittleEndian.PutUint16((*m)[p:], v)
}
func append32(m *[]byte, v uint32) {
p := len(*m)
*m = append(*m, 0, 0, 0, 0)
binary.LittleEndian.PutUint32((*m)[p:], v)
}
func append64(m *[]byte, v uint64) {
p := len(*m)
*m = append(*m, 0, 0, 0, 0, 0, 0, 0, 0)
binary.LittleEndian.PutUint64((*m)[p:], v)
}
func expandmm(m *[]byte, n int, v byte) {
sl := (*_GoSlice)(unsafe.Pointer(m))
nb := sl.len + n
/* grow as needed */
if nb > cap(*m) {
*m = growslice(byteType, *m, nb)
}
/* fill the new area */
memset(unsafe.Pointer(uintptr(sl.ptr)+uintptr(sl.len)), v, uintptr(n))
sl.len = nb
}
func memset(p unsafe.Pointer, c byte, n uintptr) {
if c != 0 {
memsetv(p, c, n)
} else {
memclrNoHeapPointers(p, n)
}
}
func memsetv(p unsafe.Pointer, c byte, n uintptr) {
for i := uintptr(0); i < n; i++ {
*(*byte)(unsafe.Pointer(uintptr(p) + i)) = c
}
}
func literal64(v string) (uint64, error) {
var nb int
var ch rune
var ex error
var mm [12]byte
/* unquote the runes */
for v != "" {
if ch, _, v, ex = strconv.UnquoteChar(v, '\''); ex != nil {
return 0, ex
} else if nb += utf8.EncodeRune(mm[nb:], ch); nb > 8 {
return 0, errors.New("multi-char constant too large")
}
}
/* convert to uint64 */
return *(*uint64)(unsafe.Pointer(&mm)), nil
}
var (
byteWrap = reflect.TypeOf(byte(0))
byteType = (*_GoType)(efaceOf(byteWrap).ptr)
)
//go:linkname growslice runtime.growslice
func growslice(_ *_GoType, _ []byte, _ int) []byte
//go:noescape
//go:linkname memclrNoHeapPointers runtime.memclrNoHeapPointers
func memclrNoHeapPointers(_ unsafe.Pointer, _ uintptr)
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/internal/iasm/x86_64/instructions_table.go | vendor/github.com/bytedance/sonic/loader/internal/iasm/x86_64/instructions_table.go | //
// Copyright 2024 CloudWeGo Authors
//
// 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.
//
// Code generated by "mkasm_amd64.py", DO NOT EDIT.
package x86_64
const (
_N_args = 5
_N_forms = 23
)
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/internal/iasm/x86_64/encodings.go | vendor/github.com/bytedance/sonic/loader/internal/iasm/x86_64/encodings.go | //
// Copyright 2024 CloudWeGo Authors
//
// 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 x86_64
import (
"encoding/binary"
"math"
)
/** Operand Encoding Helpers **/
func imml(v interface{}) byte {
return byte(toImmAny(v) & 0x0f)
}
func relv(v interface{}) int64 {
switch r := v.(type) {
case *Label:
return 0
case RelativeOffset:
return int64(r)
default:
panic("invalid relative offset")
}
}
func addr(v interface{}) interface{} {
switch a := v.(*MemoryOperand).Addr; a.Type {
case Memory:
return a.Memory
case Offset:
return a.Offset
case Reference:
return a.Reference
default:
panic("invalid memory operand type")
}
}
func bcode(v interface{}) byte {
if m, ok := v.(*MemoryOperand); !ok {
panic("v is not a memory operand")
} else if m.Broadcast == 0 {
return 0
} else {
return 1
}
}
func vcode(v interface{}) byte {
switch r := v.(type) {
case XMMRegister:
return byte(r)
case YMMRegister:
return byte(r)
case ZMMRegister:
return byte(r)
case MaskedRegister:
return vcode(r.Reg)
default:
panic("v is not a vector register")
}
}
func kcode(v interface{}) byte {
switch r := v.(type) {
case KRegister:
return byte(r)
case XMMRegister:
return 0
case YMMRegister:
return 0
case ZMMRegister:
return 0
case RegisterMask:
return byte(r.K)
case MaskedRegister:
return byte(r.Mask.K)
case *MemoryOperand:
return toKcodeMem(r)
default:
panic("v is not a maskable operand")
}
}
func zcode(v interface{}) byte {
switch r := v.(type) {
case KRegister:
return 0
case XMMRegister:
return 0
case YMMRegister:
return 0
case ZMMRegister:
return 0
case RegisterMask:
return toZcodeRegM(r)
case MaskedRegister:
return toZcodeRegM(r.Mask)
case *MemoryOperand:
return toZcodeMem(r)
default:
panic("v is not a maskable operand")
}
}
func lcode(v interface{}) byte {
switch r := v.(type) {
case Register8:
return byte(r & 0x07)
case Register16:
return byte(r & 0x07)
case Register32:
return byte(r & 0x07)
case Register64:
return byte(r & 0x07)
case KRegister:
return byte(r & 0x07)
case MMRegister:
return byte(r & 0x07)
case XMMRegister:
return byte(r & 0x07)
case YMMRegister:
return byte(r & 0x07)
case ZMMRegister:
return byte(r & 0x07)
case MaskedRegister:
return lcode(r.Reg)
default:
panic("v is not a register")
}
}
func hcode(v interface{}) byte {
switch r := v.(type) {
case Register8:
return byte(r>>3) & 1
case Register16:
return byte(r>>3) & 1
case Register32:
return byte(r>>3) & 1
case Register64:
return byte(r>>3) & 1
case KRegister:
return byte(r>>3) & 1
case MMRegister:
return byte(r>>3) & 1
case XMMRegister:
return byte(r>>3) & 1
case YMMRegister:
return byte(r>>3) & 1
case ZMMRegister:
return byte(r>>3) & 1
case MaskedRegister:
return hcode(r.Reg)
default:
panic("v is not a register")
}
}
func ecode(v interface{}) byte {
switch r := v.(type) {
case Register8:
return byte(r>>4) & 1
case Register16:
return byte(r>>4) & 1
case Register32:
return byte(r>>4) & 1
case Register64:
return byte(r>>4) & 1
case KRegister:
return byte(r>>4) & 1
case MMRegister:
return byte(r>>4) & 1
case XMMRegister:
return byte(r>>4) & 1
case YMMRegister:
return byte(r>>4) & 1
case ZMMRegister:
return byte(r>>4) & 1
case MaskedRegister:
return ecode(r.Reg)
default:
panic("v is not a register")
}
}
func hlcode(v interface{}) byte {
switch r := v.(type) {
case Register8:
return toHLcodeReg8(r)
case Register16:
return byte(r & 0x0f)
case Register32:
return byte(r & 0x0f)
case Register64:
return byte(r & 0x0f)
case KRegister:
return byte(r & 0x0f)
case MMRegister:
return byte(r & 0x0f)
case XMMRegister:
return byte(r & 0x0f)
case YMMRegister:
return byte(r & 0x0f)
case ZMMRegister:
return byte(r & 0x0f)
case MaskedRegister:
return hlcode(r.Reg)
default:
panic("v is not a register")
}
}
func ehcode(v interface{}) byte {
switch r := v.(type) {
case Register8:
return byte(r>>3) & 0x03
case Register16:
return byte(r>>3) & 0x03
case Register32:
return byte(r>>3) & 0x03
case Register64:
return byte(r>>3) & 0x03
case KRegister:
return byte(r>>3) & 0x03
case MMRegister:
return byte(r>>3) & 0x03
case XMMRegister:
return byte(r>>3) & 0x03
case YMMRegister:
return byte(r>>3) & 0x03
case ZMMRegister:
return byte(r>>3) & 0x03
case MaskedRegister:
return ehcode(r.Reg)
default:
panic("v is not a register")
}
}
func toImmAny(v interface{}) int64 {
if x, ok := asInt64(v); ok {
return x
} else {
panic("value is not an integer")
}
}
func toHcodeOpt(v interface{}) byte {
if v == nil {
return 0
} else {
return hcode(v)
}
}
func toEcodeVMM(v interface{}, x byte) byte {
switch r := v.(type) {
case XMMRegister:
return ecode(r)
case YMMRegister:
return ecode(r)
case ZMMRegister:
return ecode(r)
default:
return x
}
}
func toKcodeMem(v *MemoryOperand) byte {
if !v.Masked {
return 0
} else {
return byte(v.Mask.K)
}
}
func toZcodeMem(v *MemoryOperand) byte {
if !v.Masked || v.Mask.Z {
return 0
} else {
return 1
}
}
func toZcodeRegM(v RegisterMask) byte {
if v.Z {
return 1
} else {
return 0
}
}
func toHLcodeReg8(v Register8) byte {
switch v {
case AH:
fallthrough
case BH:
fallthrough
case CH:
fallthrough
case DH:
panic("ah/bh/ch/dh registers never use 4-bit encoding")
default:
return byte(v & 0x0f)
}
}
/** Instruction Encoding Helpers **/
const (
_N_inst = 16
)
const (
_F_rel1 = 1 << iota
_F_rel4
)
type _Encoding struct {
len int
flags int
bytes [_N_inst]byte
encoder func(m *_Encoding, v []interface{})
}
// buf ensures len + n <= len(bytes).
func (self *_Encoding) buf(n int) []byte {
if i := self.len; i+n > _N_inst {
panic("instruction too long")
} else {
return self.bytes[i:]
}
}
// emit encodes a single byte.
func (self *_Encoding) emit(v byte) {
self.buf(1)[0] = v
self.len++
}
// imm1 encodes a single byte immediate value.
func (self *_Encoding) imm1(v int64) {
self.emit(byte(v))
}
// imm2 encodes a two-byte immediate value in little-endian.
func (self *_Encoding) imm2(v int64) {
binary.LittleEndian.PutUint16(self.buf(2), uint16(v))
self.len += 2
}
// imm4 encodes a 4-byte immediate value in little-endian.
func (self *_Encoding) imm4(v int64) {
binary.LittleEndian.PutUint32(self.buf(4), uint32(v))
self.len += 4
}
// imm8 encodes an 8-byte immediate value in little-endian.
func (self *_Encoding) imm8(v int64) {
binary.LittleEndian.PutUint64(self.buf(8), uint64(v))
self.len += 8
}
// vex2 encodes a 2-byte or 3-byte VEX prefix.
//
// 2-byte VEX prefix:
//
// Requires: VEX.W = 0, VEX.mmmmm = 0b00001 and VEX.B = VEX.X = 0
//
// +----------------+
//
// Byte 0: | Bits 0-7: 0xc5 |
//
// +----------------+
//
// +-----------+----------------+----------+--------------+
//
// Byte 1: | Bit 7: ~R | Bits 3-6 ~vvvv | Bit 2: L | Bits 0-1: pp |
//
// +-----------+----------------+----------+--------------+
//
// 3-byte VEX prefix:
// +----------------+
//
// Byte 0: | Bits 0-7: 0xc4 |
//
// +----------------+
//
// +-----------+-----------+-----------+-------------------+
//
// Byte 1: | Bit 7: ~R | Bit 6: ~X | Bit 5: ~B | Bits 0-4: 0b00001 |
//
// +-----------+-----------+-----------+-------------------+
//
// +----------+-----------------+----------+--------------+
//
// Byte 2: | Bit 7: 0 | Bits 3-6: ~vvvv | Bit 2: L | Bits 0-1: pp |
//
// +----------+-----------------+----------+--------------+
func (self *_Encoding) vex2(lpp byte, r byte, rm interface{}, vvvv byte) {
var b byte
var x byte
/* VEX.R must be a single-bit mask */
if r > 1 {
panic("VEX.R must be a 1-bit mask")
}
/* VEX.Lpp must be a 3-bit mask */
if lpp&^0b111 != 0 {
panic("VEX.Lpp must be a 3-bit mask")
}
/* VEX.vvvv must be a 4-bit mask */
if vvvv&^0b1111 != 0 {
panic("VEX.vvvv must be a 4-bit mask")
}
/* encode the RM bits if any */
if rm != nil {
switch v := rm.(type) {
case *Label:
break
case Register:
b = hcode(v)
case MemoryAddress:
b, x = toHcodeOpt(v.Base), toHcodeOpt(v.Index)
case RelativeOffset:
break
default:
panic("rm is expected to be a register or a memory address")
}
}
/* if VEX.B and VEX.X are zeroes, 2-byte VEX prefix can be used */
if x == 0 && b == 0 {
self.emit(0xc5)
self.emit(0xf8 ^ (r << 7) ^ (vvvv << 3) ^ lpp)
} else {
self.emit(0xc4)
self.emit(0xe1 ^ (r << 7) ^ (x << 6) ^ (b << 5))
self.emit(0x78 ^ (vvvv << 3) ^ lpp)
}
}
// vex3 encodes a 3-byte VEX or XOP prefix.
//
// 3-byte VEX/XOP prefix
// +-----------------------------------+
//
// Byte 0: | Bits 0-7: 0xc4 (VEX) / 0x8f (XOP) |
//
// +-----------------------------------+
//
// +-----------+-----------+-----------+-----------------+
//
// Byte 1: | Bit 7: ~R | Bit 6: ~X | Bit 5: ~B | Bits 0-4: mmmmm |
//
// +-----------+-----------+-----------+-----------------+
//
// +----------+-----------------+----------+--------------+
//
// Byte 2: | Bit 7: W | Bits 3-6: ~vvvv | Bit 2: L | Bits 0-1: pp |
//
// +----------+-----------------+----------+--------------+
func (self *_Encoding) vex3(esc byte, mmmmm byte, wlpp byte, r byte, rm interface{}, vvvv byte) {
var b byte
var x byte
/* VEX.R must be a single-bit mask */
if r > 1 {
panic("VEX.R must be a 1-bit mask")
}
/* VEX.vvvv must be a 4-bit mask */
if vvvv&^0b1111 != 0 {
panic("VEX.vvvv must be a 4-bit mask")
}
/* escape must be a 3-byte VEX (0xc4) or XOP (0x8f) prefix */
if esc != 0xc4 && esc != 0x8f {
panic("escape must be a 3-byte VEX (0xc4) or XOP (0x8f) prefix")
}
/* VEX.W____Lpp is expected to have no bits set except 0, 1, 2 and 7 */
if wlpp&^0b10000111 != 0 {
panic("VEX.W____Lpp is expected to have no bits set except 0, 1, 2 and 7")
}
/* VEX.m-mmmm is expected to be a 5-bit mask */
if mmmmm&^0b11111 != 0 {
panic("VEX.m-mmmm is expected to be a 5-bit mask")
}
/* encode the RM bits */
switch v := rm.(type) {
case *Label:
break
case MemoryAddress:
b, x = toHcodeOpt(v.Base), toHcodeOpt(v.Index)
case RelativeOffset:
break
default:
panic("rm is expected to be a register or a memory address")
}
/* encode the 3-byte VEX or XOP prefix */
self.emit(esc)
self.emit(0xe0 ^ (r << 7) ^ (x << 6) ^ (b << 5) ^ mmmmm)
self.emit(0x78 ^ (vvvv << 3) ^ wlpp)
}
// evex encodes a 4-byte EVEX prefix.
func (self *_Encoding) evex(mm byte, w1pp byte, ll byte, rr byte, rm interface{}, vvvvv byte, aaa byte, zz byte, bb byte) {
var b byte
var x byte
/* EVEX.b must be a single-bit mask */
if bb > 1 {
panic("EVEX.b must be a 1-bit mask")
}
/* EVEX.z must be a single-bit mask */
if zz > 1 {
panic("EVEX.z must be a 1-bit mask")
}
/* EVEX.mm must be a 2-bit mask */
if mm&^0b11 != 0 {
panic("EVEX.mm must be a 2-bit mask")
}
/* EVEX.L'L must be a 2-bit mask */
if ll&^0b11 != 0 {
panic("EVEX.L'L must be a 2-bit mask")
}
/* EVEX.R'R must be a 2-bit mask */
if rr&^0b11 != 0 {
panic("EVEX.R'R must be a 2-bit mask")
}
/* EVEX.aaa must be a 3-bit mask */
if aaa&^0b111 != 0 {
panic("EVEX.aaa must be a 3-bit mask")
}
/* EVEX.v'vvvv must be a 5-bit mask */
if vvvvv&^0b11111 != 0 {
panic("EVEX.v'vvvv must be a 5-bit mask")
}
/* EVEX.W____1pp is expected to have no bits set except 0, 1, 2, and 7 */
if w1pp&^0b10000011 != 0b100 {
panic("EVEX.W____1pp is expected to have no bits set except 0, 1, 2, and 7")
}
/* extract bits from EVEX.R'R and EVEX.v'vvvv */
r1, r0 := rr>>1, rr&1
v1, v0 := vvvvv>>4, vvvvv&0b1111
/* encode the RM bits if any */
if rm != nil {
switch m := rm.(type) {
case *Label:
break
case Register:
b, x = hcode(m), ecode(m)
case MemoryAddress:
b, x, v1 = toHcodeOpt(m.Base), toHcodeOpt(m.Index), toEcodeVMM(m.Index, v1)
case RelativeOffset:
break
default:
panic("rm is expected to be a register or a memory address")
}
}
/* EVEX prefix bytes */
p0 := (r0 << 7) | (x << 6) | (b << 5) | (r1 << 4) | mm
p1 := (v0 << 3) | w1pp
p2 := (zz << 7) | (ll << 5) | (b << 4) | (v1 << 3) | aaa
/* p0: invert RXBR' (bits 4-7)
* p1: invert vvvv (bits 3-6)
* p2: invert V' (bit 3) */
self.emit(0x62)
self.emit(p0 ^ 0xf0)
self.emit(p1 ^ 0x78)
self.emit(p2 ^ 0x08)
}
// rexm encodes a mandatory REX prefix.
func (self *_Encoding) rexm(w byte, r byte, rm interface{}) {
var b byte
var x byte
/* REX.R must be 0 or 1 */
if r != 0 && r != 1 {
panic("REX.R must be 0 or 1")
}
/* REX.W must be 0 or 1 */
if w != 0 && w != 1 {
panic("REX.W must be 0 or 1")
}
/* encode the RM bits */
switch v := rm.(type) {
case *Label:
break
case MemoryAddress:
b, x = toHcodeOpt(v.Base), toHcodeOpt(v.Index)
case RelativeOffset:
break
default:
panic("rm is expected to be a register or a memory address")
}
/* encode the REX prefix */
self.emit(0x40 | (w << 3) | (r << 2) | (x << 1) | b)
}
// rexo encodes an optional REX prefix.
func (self *_Encoding) rexo(r byte, rm interface{}, force bool) {
var b byte
var x byte
/* REX.R must be 0 or 1 */
if r != 0 && r != 1 {
panic("REX.R must be 0 or 1")
}
/* encode the RM bits */
switch v := rm.(type) {
case *Label:
break
case Register:
b = hcode(v)
case MemoryAddress:
b, x = toHcodeOpt(v.Base), toHcodeOpt(v.Index)
case RelativeOffset:
break
default:
panic("rm is expected to be a register or a memory address")
}
/* if REX.R, REX.X, and REX.B are all zeroes, REX prefix can be omitted */
if force || r != 0 || x != 0 || b != 0 {
self.emit(0x40 | (r << 2) | (x << 1) | b)
}
}
// mrsd encodes ModR/M, SIB and Displacement.
//
// ModR/M byte
//
// +----------------+---------------+---------------+
// | Bits 6-7: Mode | Bits 3-5: Reg | Bits 0-2: R/M |
// +----------------+---------------+---------------+
//
// SIB byte
//
// +-----------------+-----------------+----------------+
// | Bits 6-7: Scale | Bits 3-5: Index | Bits 0-2: Base |
// +-----------------+-----------------+----------------+
func (self *_Encoding) mrsd(reg byte, rm interface{}, disp8v int32) {
var ok bool
var mm MemoryAddress
var ro RelativeOffset
/* ModRM encodes the lower 3-bit of the register */
if reg > 7 {
panic("invalid register bits")
}
/* check the displacement scale */
switch disp8v {
case 1:
break
case 2:
break
case 4:
break
case 8:
break
case 16:
break
case 32:
break
case 64:
break
default:
panic("invalid displacement size")
}
/* special case: unresolved labels, assuming a zero offset */
if _, ok = rm.(*Label); ok {
self.emit(0x05 | (reg << 3))
self.imm4(0)
return
}
/* special case: RIP-relative offset
* ModRM.Mode == 0 and ModeRM.R/M == 5 indicates (rip + disp32) addressing */
if ro, ok = rm.(RelativeOffset); ok {
self.emit(0x05 | (reg << 3))
self.imm4(int64(ro))
return
}
/* must be a generic memory address */
if mm, ok = rm.(MemoryAddress); !ok {
panic("rm must be a memory address")
}
/* absolute addressing, encoded as disp(%rbp,%rsp,1) */
if mm.Base == nil && mm.Index == nil {
self.emit(0x04 | (reg << 3))
self.emit(0x25)
self.imm4(int64(mm.Displacement))
return
}
/* no SIB byte */
if mm.Index == nil && lcode(mm.Base) != 0b100 {
cc := lcode(mm.Base)
dv := mm.Displacement
/* ModRM.Mode == 0 (no displacement) */
if dv == 0 && mm.Base != RBP && mm.Base != R13 {
if cc == 0b101 {
panic("rbp/r13 is not encodable as a base register (interpreted as disp32 address)")
} else {
self.emit((reg << 3) | cc)
return
}
}
/* ModRM.Mode == 1 (8-bit displacement) */
if dq := dv / disp8v; dq >= math.MinInt8 && dq <= math.MaxInt8 && dv%disp8v == 0 {
self.emit(0x40 | (reg << 3) | cc)
self.imm1(int64(dq))
return
}
/* ModRM.Mode == 2 (32-bit displacement) */
self.emit(0x80 | (reg << 3) | cc)
self.imm4(int64(mm.Displacement))
return
}
/* all encodings below use ModRM.R/M = 4 (0b100) to indicate the presence of SIB */
if mm.Index == RSP {
panic("rsp is not encodable as an index register (interpreted as no index)")
}
/* index = 4 (0b100) denotes no-index encoding */
var scale byte
var index byte = 0x04
/* encode the scale byte */
if mm.Scale != 0 {
switch mm.Scale {
case 1:
scale = 0
case 2:
scale = 1
case 4:
scale = 2
case 8:
scale = 3
default:
panic("invalid scale value")
}
}
/* encode the index byte */
if mm.Index != nil {
index = lcode(mm.Index)
}
/* SIB.Base = 5 (0b101) and ModRM.Mode = 0 indicates no-base encoding with disp32 */
if mm.Base == nil {
self.emit((reg << 3) | 0b100)
self.emit((scale << 6) | (index << 3) | 0b101)
self.imm4(int64(mm.Displacement))
return
}
/* base L-code & displacement value */
cc := lcode(mm.Base)
dv := mm.Displacement
/* ModRM.Mode == 0 (no displacement) */
if dv == 0 && cc != 0b101 {
self.emit((reg << 3) | 0b100)
self.emit((scale << 6) | (index << 3) | cc)
return
}
/* ModRM.Mode == 1 (8-bit displacement) */
if dq := dv / disp8v; dq >= math.MinInt8 && dq <= math.MaxInt8 && dv%disp8v == 0 {
self.emit(0x44 | (reg << 3))
self.emit((scale << 6) | (index << 3) | cc)
self.imm1(int64(dq))
return
}
/* ModRM.Mode == 2 (32-bit displacement) */
self.emit(0x84 | (reg << 3))
self.emit((scale << 6) | (index << 3) | cc)
self.imm4(int64(mm.Displacement))
}
// encode invokes the encoder to encode this instruction.
func (self *_Encoding) encode(v []interface{}) int {
self.len = 0
self.encoder(self, v)
return self.len
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/internal/iasm/x86_64/registers.go | vendor/github.com/bytedance/sonic/loader/internal/iasm/x86_64/registers.go | //
// Copyright 2024 CloudWeGo Authors
//
// 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 x86_64
import (
"fmt"
)
// Register represents a hardware register.
type Register interface {
fmt.Stringer
implRegister()
}
type (
Register8 byte
Register16 byte
Register32 byte
Register64 byte
)
type (
KRegister byte
MMRegister byte
XMMRegister byte
YMMRegister byte
ZMMRegister byte
)
// RegisterMask is a KRegister used to mask another register.
type RegisterMask struct {
Z bool
K KRegister
}
// String implements the fmt.Stringer interface.
func (self RegisterMask) String() string {
if !self.Z {
return fmt.Sprintf("{%%%s}", self.K)
} else {
return fmt.Sprintf("{%%%s}{z}", self.K)
}
}
// MaskedRegister is a Register masked by a RegisterMask.
type MaskedRegister struct {
Reg Register
Mask RegisterMask
}
// String implements the fmt.Stringer interface.
func (self MaskedRegister) String() string {
return self.Reg.String() + self.Mask.String()
}
const (
AL Register8 = iota
CL
DL
BL
SPL
BPL
SIL
DIL
R8b
R9b
R10b
R11b
R12b
R13b
R14b
R15b
)
const (
AH = SPL | 0x80
CH = BPL | 0x80
DH = SIL | 0x80
BH = DIL | 0x80
)
const (
AX Register16 = iota
CX
DX
BX
SP
BP
SI
DI
R8w
R9w
R10w
R11w
R12w
R13w
R14w
R15w
)
const (
EAX Register32 = iota
ECX
EDX
EBX
ESP
EBP
ESI
EDI
R8d
R9d
R10d
R11d
R12d
R13d
R14d
R15d
)
const (
RAX Register64 = iota
RCX
RDX
RBX
RSP
RBP
RSI
RDI
R8
R9
R10
R11
R12
R13
R14
R15
)
const (
K0 KRegister = iota
K1
K2
K3
K4
K5
K6
K7
)
const (
MM0 MMRegister = iota
MM1
MM2
MM3
MM4
MM5
MM6
MM7
)
const (
XMM0 XMMRegister = iota
XMM1
XMM2
XMM3
XMM4
XMM5
XMM6
XMM7
XMM8
XMM9
XMM10
XMM11
XMM12
XMM13
XMM14
XMM15
XMM16
XMM17
XMM18
XMM19
XMM20
XMM21
XMM22
XMM23
XMM24
XMM25
XMM26
XMM27
XMM28
XMM29
XMM30
XMM31
)
const (
YMM0 YMMRegister = iota
YMM1
YMM2
YMM3
YMM4
YMM5
YMM6
YMM7
YMM8
YMM9
YMM10
YMM11
YMM12
YMM13
YMM14
YMM15
YMM16
YMM17
YMM18
YMM19
YMM20
YMM21
YMM22
YMM23
YMM24
YMM25
YMM26
YMM27
YMM28
YMM29
YMM30
YMM31
)
const (
ZMM0 ZMMRegister = iota
ZMM1
ZMM2
ZMM3
ZMM4
ZMM5
ZMM6
ZMM7
ZMM8
ZMM9
ZMM10
ZMM11
ZMM12
ZMM13
ZMM14
ZMM15
ZMM16
ZMM17
ZMM18
ZMM19
ZMM20
ZMM21
ZMM22
ZMM23
ZMM24
ZMM25
ZMM26
ZMM27
ZMM28
ZMM29
ZMM30
ZMM31
)
func (self Register8) implRegister() {}
func (self Register16) implRegister() {}
func (self Register32) implRegister() {}
func (self Register64) implRegister() {}
func (self KRegister) implRegister() {}
func (self MMRegister) implRegister() {}
func (self XMMRegister) implRegister() {}
func (self YMMRegister) implRegister() {}
func (self ZMMRegister) implRegister() {}
func (self Register8) String() string {
if int(self) >= len(r8names) {
return "???"
} else {
return r8names[self]
}
}
func (self Register16) String() string {
if int(self) >= len(r16names) {
return "???"
} else {
return r16names[self]
}
}
func (self Register32) String() string {
if int(self) >= len(r32names) {
return "???"
} else {
return r32names[self]
}
}
func (self Register64) String() string {
if int(self) >= len(r64names) {
return "???"
} else {
return r64names[self]
}
}
func (self KRegister) String() string {
if int(self) >= len(knames) {
return "???"
} else {
return knames[self]
}
}
func (self MMRegister) String() string {
if int(self) >= len(mmnames) {
return "???"
} else {
return mmnames[self]
}
}
func (self XMMRegister) String() string {
if int(self) >= len(xmmnames) {
return "???"
} else {
return xmmnames[self]
}
}
func (self YMMRegister) String() string {
if int(self) >= len(ymmnames) {
return "???"
} else {
return ymmnames[self]
}
}
func (self ZMMRegister) String() string {
if int(self) >= len(zmmnames) {
return "???"
} else {
return zmmnames[self]
}
}
// Registers maps register name into Register instances.
var Registers = map[string]Register{
"al": AL,
"cl": CL,
"dl": DL,
"bl": BL,
"spl": SPL,
"bpl": BPL,
"sil": SIL,
"dil": DIL,
"r8b": R8b,
"r9b": R9b,
"r10b": R10b,
"r11b": R11b,
"r12b": R12b,
"r13b": R13b,
"r14b": R14b,
"r15b": R15b,
"ah": AH,
"ch": CH,
"dh": DH,
"bh": BH,
"ax": AX,
"cx": CX,
"dx": DX,
"bx": BX,
"sp": SP,
"bp": BP,
"si": SI,
"di": DI,
"r8w": R8w,
"r9w": R9w,
"r10w": R10w,
"r11w": R11w,
"r12w": R12w,
"r13w": R13w,
"r14w": R14w,
"r15w": R15w,
"eax": EAX,
"ecx": ECX,
"edx": EDX,
"ebx": EBX,
"esp": ESP,
"ebp": EBP,
"esi": ESI,
"edi": EDI,
"r8d": R8d,
"r9d": R9d,
"r10d": R10d,
"r11d": R11d,
"r12d": R12d,
"r13d": R13d,
"r14d": R14d,
"r15d": R15d,
"rax": RAX,
"rcx": RCX,
"rdx": RDX,
"rbx": RBX,
"rsp": RSP,
"rbp": RBP,
"rsi": RSI,
"rdi": RDI,
"r8": R8,
"r9": R9,
"r10": R10,
"r11": R11,
"r12": R12,
"r13": R13,
"r14": R14,
"r15": R15,
"k0": K0,
"k1": K1,
"k2": K2,
"k3": K3,
"k4": K4,
"k5": K5,
"k6": K6,
"k7": K7,
"mm0": MM0,
"mm1": MM1,
"mm2": MM2,
"mm3": MM3,
"mm4": MM4,
"mm5": MM5,
"mm6": MM6,
"mm7": MM7,
"xmm0": XMM0,
"xmm1": XMM1,
"xmm2": XMM2,
"xmm3": XMM3,
"xmm4": XMM4,
"xmm5": XMM5,
"xmm6": XMM6,
"xmm7": XMM7,
"xmm8": XMM8,
"xmm9": XMM9,
"xmm10": XMM10,
"xmm11": XMM11,
"xmm12": XMM12,
"xmm13": XMM13,
"xmm14": XMM14,
"xmm15": XMM15,
"xmm16": XMM16,
"xmm17": XMM17,
"xmm18": XMM18,
"xmm19": XMM19,
"xmm20": XMM20,
"xmm21": XMM21,
"xmm22": XMM22,
"xmm23": XMM23,
"xmm24": XMM24,
"xmm25": XMM25,
"xmm26": XMM26,
"xmm27": XMM27,
"xmm28": XMM28,
"xmm29": XMM29,
"xmm30": XMM30,
"xmm31": XMM31,
"ymm0": YMM0,
"ymm1": YMM1,
"ymm2": YMM2,
"ymm3": YMM3,
"ymm4": YMM4,
"ymm5": YMM5,
"ymm6": YMM6,
"ymm7": YMM7,
"ymm8": YMM8,
"ymm9": YMM9,
"ymm10": YMM10,
"ymm11": YMM11,
"ymm12": YMM12,
"ymm13": YMM13,
"ymm14": YMM14,
"ymm15": YMM15,
"ymm16": YMM16,
"ymm17": YMM17,
"ymm18": YMM18,
"ymm19": YMM19,
"ymm20": YMM20,
"ymm21": YMM21,
"ymm22": YMM22,
"ymm23": YMM23,
"ymm24": YMM24,
"ymm25": YMM25,
"ymm26": YMM26,
"ymm27": YMM27,
"ymm28": YMM28,
"ymm29": YMM29,
"ymm30": YMM30,
"ymm31": YMM31,
"zmm0": ZMM0,
"zmm1": ZMM1,
"zmm2": ZMM2,
"zmm3": ZMM3,
"zmm4": ZMM4,
"zmm5": ZMM5,
"zmm6": ZMM6,
"zmm7": ZMM7,
"zmm8": ZMM8,
"zmm9": ZMM9,
"zmm10": ZMM10,
"zmm11": ZMM11,
"zmm12": ZMM12,
"zmm13": ZMM13,
"zmm14": ZMM14,
"zmm15": ZMM15,
"zmm16": ZMM16,
"zmm17": ZMM17,
"zmm18": ZMM18,
"zmm19": ZMM19,
"zmm20": ZMM20,
"zmm21": ZMM21,
"zmm22": ZMM22,
"zmm23": ZMM23,
"zmm24": ZMM24,
"zmm25": ZMM25,
"zmm26": ZMM26,
"zmm27": ZMM27,
"zmm28": ZMM28,
"zmm29": ZMM29,
"zmm30": ZMM30,
"zmm31": ZMM31,
}
/** Register Name Tables **/
var r8names = [...]string{
AL: "al",
CL: "cl",
DL: "dl",
BL: "bl",
SPL: "spl",
BPL: "bpl",
SIL: "sil",
DIL: "dil",
R8b: "r8b",
R9b: "r9b",
R10b: "r10b",
R11b: "r11b",
R12b: "r12b",
R13b: "r13b",
R14b: "r14b",
R15b: "r15b",
AH: "ah",
CH: "ch",
DH: "dh",
BH: "bh",
}
var r16names = [...]string{
AX: "ax",
CX: "cx",
DX: "dx",
BX: "bx",
SP: "sp",
BP: "bp",
SI: "si",
DI: "di",
R8w: "r8w",
R9w: "r9w",
R10w: "r10w",
R11w: "r11w",
R12w: "r12w",
R13w: "r13w",
R14w: "r14w",
R15w: "r15w",
}
var r32names = [...]string{
EAX: "eax",
ECX: "ecx",
EDX: "edx",
EBX: "ebx",
ESP: "esp",
EBP: "ebp",
ESI: "esi",
EDI: "edi",
R8d: "r8d",
R9d: "r9d",
R10d: "r10d",
R11d: "r11d",
R12d: "r12d",
R13d: "r13d",
R14d: "r14d",
R15d: "r15d",
}
var r64names = [...]string{
RAX: "rax",
RCX: "rcx",
RDX: "rdx",
RBX: "rbx",
RSP: "rsp",
RBP: "rbp",
RSI: "rsi",
RDI: "rdi",
R8: "r8",
R9: "r9",
R10: "r10",
R11: "r11",
R12: "r12",
R13: "r13",
R14: "r14",
R15: "r15",
}
var knames = [...]string{
K0: "k0",
K1: "k1",
K2: "k2",
K3: "k3",
K4: "k4",
K5: "k5",
K6: "k6",
K7: "k7",
}
var mmnames = [...]string{
MM0: "mm0",
MM1: "mm1",
MM2: "mm2",
MM3: "mm3",
MM4: "mm4",
MM5: "mm5",
MM6: "mm6",
MM7: "mm7",
}
var xmmnames = [...]string{
XMM0: "xmm0",
XMM1: "xmm1",
XMM2: "xmm2",
XMM3: "xmm3",
XMM4: "xmm4",
XMM5: "xmm5",
XMM6: "xmm6",
XMM7: "xmm7",
XMM8: "xmm8",
XMM9: "xmm9",
XMM10: "xmm10",
XMM11: "xmm11",
XMM12: "xmm12",
XMM13: "xmm13",
XMM14: "xmm14",
XMM15: "xmm15",
XMM16: "xmm16",
XMM17: "xmm17",
XMM18: "xmm18",
XMM19: "xmm19",
XMM20: "xmm20",
XMM21: "xmm21",
XMM22: "xmm22",
XMM23: "xmm23",
XMM24: "xmm24",
XMM25: "xmm25",
XMM26: "xmm26",
XMM27: "xmm27",
XMM28: "xmm28",
XMM29: "xmm29",
XMM30: "xmm30",
XMM31: "xmm31",
}
var ymmnames = [...]string{
YMM0: "ymm0",
YMM1: "ymm1",
YMM2: "ymm2",
YMM3: "ymm3",
YMM4: "ymm4",
YMM5: "ymm5",
YMM6: "ymm6",
YMM7: "ymm7",
YMM8: "ymm8",
YMM9: "ymm9",
YMM10: "ymm10",
YMM11: "ymm11",
YMM12: "ymm12",
YMM13: "ymm13",
YMM14: "ymm14",
YMM15: "ymm15",
YMM16: "ymm16",
YMM17: "ymm17",
YMM18: "ymm18",
YMM19: "ymm19",
YMM20: "ymm20",
YMM21: "ymm21",
YMM22: "ymm22",
YMM23: "ymm23",
YMM24: "ymm24",
YMM25: "ymm25",
YMM26: "ymm26",
YMM27: "ymm27",
YMM28: "ymm28",
YMM29: "ymm29",
YMM30: "ymm30",
YMM31: "ymm31",
}
var zmmnames = [...]string{
ZMM0: "zmm0",
ZMM1: "zmm1",
ZMM2: "zmm2",
ZMM3: "zmm3",
ZMM4: "zmm4",
ZMM5: "zmm5",
ZMM6: "zmm6",
ZMM7: "zmm7",
ZMM8: "zmm8",
ZMM9: "zmm9",
ZMM10: "zmm10",
ZMM11: "zmm11",
ZMM12: "zmm12",
ZMM13: "zmm13",
ZMM14: "zmm14",
ZMM15: "zmm15",
ZMM16: "zmm16",
ZMM17: "zmm17",
ZMM18: "zmm18",
ZMM19: "zmm19",
ZMM20: "zmm20",
ZMM21: "zmm21",
ZMM22: "zmm22",
ZMM23: "zmm23",
ZMM24: "zmm24",
ZMM25: "zmm25",
ZMM26: "zmm26",
ZMM27: "zmm27",
ZMM28: "zmm28",
ZMM29: "zmm29",
ZMM30: "zmm30",
ZMM31: "zmm31",
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/internal/iasm/x86_64/program.go | vendor/github.com/bytedance/sonic/loader/internal/iasm/x86_64/program.go | //
// Copyright 2024 CloudWeGo Authors
//
// 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 x86_64
import (
"fmt"
"math"
"math/bits"
"github.com/bytedance/sonic/loader/internal/iasm/expr"
)
type (
_PseudoType int
_InstructionEncoder func(*Program, ...interface{}) *Instruction
)
const (
_PseudoNop _PseudoType = iota + 1
_PseudoByte
_PseudoWord
_PseudoLong
_PseudoQuad
_PseudoData
_PseudoAlign
)
func (self _PseudoType) String() string {
switch self {
case _PseudoNop:
return ".nop"
case _PseudoByte:
return ".byte"
case _PseudoWord:
return ".word"
case _PseudoLong:
return ".long"
case _PseudoQuad:
return ".quad"
case _PseudoData:
return ".data"
case _PseudoAlign:
return ".align"
default:
panic("unreachable")
}
}
type _Pseudo struct {
kind _PseudoType
data []byte
uint uint64
expr *expr.Expr
}
func (self *_Pseudo) free() {
if self.expr != nil {
self.expr.Free()
}
}
func (self *_Pseudo) encode(m *[]byte, pc uintptr) int {
switch self.kind {
case _PseudoNop:
return 0
case _PseudoByte:
self.encodeByte(m)
return 1
case _PseudoWord:
self.encodeWord(m)
return 2
case _PseudoLong:
self.encodeLong(m)
return 4
case _PseudoQuad:
self.encodeQuad(m)
return 8
case _PseudoData:
self.encodeData(m)
return len(self.data)
case _PseudoAlign:
self.encodeAlign(m, pc)
return self.alignSize(pc)
default:
panic("invalid pseudo instruction")
}
}
func (self *_Pseudo) evalExpr(low int64, high int64) int64 {
if v, err := self.expr.Evaluate(); err != nil {
panic(err)
} else if v < low || v > high {
panic(fmt.Sprintf("expression out of range [%d, %d]: %d", low, high, v))
} else {
return v
}
}
func (self *_Pseudo) alignSize(pc uintptr) int {
if !ispow2(self.uint) {
panic(fmt.Sprintf("aligment should be a power of 2, not %d", self.uint))
} else {
return align(int(pc), bits.TrailingZeros64(self.uint)) - int(pc)
}
}
func (self *_Pseudo) encodeData(m *[]byte) {
if m != nil {
*m = append(*m, self.data...)
}
}
func (self *_Pseudo) encodeByte(m *[]byte) {
if m != nil {
append8(m, byte(self.evalExpr(math.MinInt8, math.MaxUint8)))
}
}
func (self *_Pseudo) encodeWord(m *[]byte) {
if m != nil {
append16(m, uint16(self.evalExpr(math.MinInt16, math.MaxUint16)))
}
}
func (self *_Pseudo) encodeLong(m *[]byte) {
if m != nil {
append32(m, uint32(self.evalExpr(math.MinInt32, math.MaxUint32)))
}
}
func (self *_Pseudo) encodeQuad(m *[]byte) {
if m != nil {
if v, err := self.expr.Evaluate(); err != nil {
panic(err)
} else {
append64(m, uint64(v))
}
}
}
func (self *_Pseudo) encodeAlign(m *[]byte, pc uintptr) {
if m != nil {
if self.expr == nil {
expandmm(m, self.alignSize(pc), 0)
} else {
expandmm(m, self.alignSize(pc), byte(self.evalExpr(math.MinInt8, math.MaxUint8)))
}
}
}
// Operands represents a sequence of operand required by an instruction.
type Operands [_N_args]interface{}
// InstructionDomain represents the domain of an instruction.
type InstructionDomain uint8
const (
DomainGeneric InstructionDomain = iota
DomainMMXSSE
DomainAVX
DomainFMA
DomainCrypto
DomainMask
DomainAMDSpecific
DomainMisc
DomainPseudo
)
type (
_BranchType uint8
)
const (
_B_none _BranchType = iota
_B_conditional
_B_unconditional
)
// Instruction represents an unencoded instruction.
type Instruction struct {
next *Instruction
pc uintptr
nb int
len int
argc int
name string
argv Operands
forms [_N_forms]_Encoding
pseudo _Pseudo
branch _BranchType
domain InstructionDomain
prefix []byte
}
func (self *Instruction) add(flags int, encoder func(m *_Encoding, v []interface{})) {
self.forms[self.len].flags = flags
self.forms[self.len].encoder = encoder
self.len++
}
func (self *Instruction) free() {
self.clear()
self.pseudo.free()
//freeInstruction(self)
}
func (self *Instruction) clear() {
for i := 0; i < self.argc; i++ {
if v, ok := self.argv[i].(Disposable); ok {
v.Free()
}
}
}
func (self *Instruction) check(e *_Encoding) bool {
if (e.flags & _F_rel1) != 0 {
return isRel8(self.argv[0])
} else if (e.flags & _F_rel4) != 0 {
return isRel32(self.argv[0]) || isLabel(self.argv[0])
} else {
return true
}
}
func (self *Instruction) encode(m *[]byte) int {
n := math.MaxInt64
p := (*_Encoding)(nil)
/* encode prefixes if any */
if self.nb = len(self.prefix); m != nil {
*m = append(*m, self.prefix...)
}
/* check for pseudo-instructions */
if self.pseudo.kind != 0 {
self.nb += self.pseudo.encode(m, self.pc)
return self.nb
}
/* find the shortest encoding */
for i := 0; i < self.len; i++ {
if e := &self.forms[i]; self.check(e) {
if v := e.encode(self.argv[:self.argc]); v < n {
n = v
p = e
}
}
}
/* add to buffer if needed */
if m != nil {
*m = append(*m, p.bytes[:n]...)
}
/* update the instruction length */
self.nb += n
return self.nb
}
/** Instruction Prefixes **/
const (
_P_cs = 0x2e
_P_ds = 0x3e
_P_es = 0x26
_P_fs = 0x64
_P_gs = 0x65
_P_ss = 0x36
_P_lock = 0xf0
)
// CS overrides the memory operation of this instruction to CS.
func (self *Instruction) CS() *Instruction {
self.prefix = append(self.prefix, _P_cs)
return self
}
// DS overrides the memory operation of this instruction to DS,
// this is the default section for most instructions if not specified.
func (self *Instruction) DS() *Instruction {
self.prefix = append(self.prefix, _P_ds)
return self
}
// ES overrides the memory operation of this instruction to ES.
func (self *Instruction) ES() *Instruction {
self.prefix = append(self.prefix, _P_es)
return self
}
// FS overrides the memory operation of this instruction to FS.
func (self *Instruction) FS() *Instruction {
self.prefix = append(self.prefix, _P_fs)
return self
}
// GS overrides the memory operation of this instruction to GS.
func (self *Instruction) GS() *Instruction {
self.prefix = append(self.prefix, _P_gs)
return self
}
// SS overrides the memory operation of this instruction to SS.
func (self *Instruction) SS() *Instruction {
self.prefix = append(self.prefix, _P_ss)
return self
}
// LOCK causes the processor's LOCK# signal to be asserted during execution of
// the accompanying instruction (turns the instruction into an atomic instruction).
// In a multiprocessor environment, the LOCK# signal insures that the processor
// has exclusive use of any shared memory while the signal is asserted.
func (self *Instruction) LOCK() *Instruction {
self.prefix = append(self.prefix, _P_lock)
return self
}
/** Basic Instruction Properties **/
// Name returns the instruction name.
func (self *Instruction) Name() string {
return self.name
}
// Domain returns the domain of this instruction.
func (self *Instruction) Domain() InstructionDomain {
return self.domain
}
// Operands returns the operands of this instruction.
func (self *Instruction) Operands() []interface{} {
return self.argv[:self.argc]
}
// Program represents a sequence of instructions.
type Program struct {
arch *Arch
head *Instruction
tail *Instruction
}
const (
_N_near = 2 // near-branch (-128 ~ +127) takes 2 bytes to encode
_N_far_cond = 6 // conditional far-branch takes 6 bytes to encode
_N_far_uncond = 5 // unconditional far-branch takes 5 bytes to encode
)
func (self *Program) clear() {
for p, q := self.head, self.head; p != nil; p = q {
q = p.next
p.free()
}
}
func (self *Program) alloc(name string, argc int, argv Operands) *Instruction {
p := self.tail
q := newInstruction(name, argc, argv)
/* attach to tail if any */
if p != nil {
p.next = q
} else {
self.head = q
}
/* set the new tail */
self.tail = q
return q
}
func (self *Program) pseudo(kind _PseudoType) (p *Instruction) {
p = self.alloc(kind.String(), 0, Operands{})
p.domain = DomainPseudo
p.pseudo.kind = kind
return
}
func (self *Program) require(isa ISA) {
if !self.arch.HasISA(isa) {
panic("ISA '" + isa.String() + "' was not enabled")
}
}
func (self *Program) branchSize(p *Instruction) int {
switch p.branch {
case _B_none:
panic("p is not a branch")
case _B_conditional:
return _N_far_cond
case _B_unconditional:
return _N_far_uncond
default:
panic("invalid instruction")
}
}
/** Pseudo-Instructions **/
// Byte is a pseudo-instruction to add raw byte to the assembled code.
func (self *Program) Byte(v *expr.Expr) (p *Instruction) {
p = self.pseudo(_PseudoByte)
p.pseudo.expr = v
return
}
// Word is a pseudo-instruction to add raw uint16 as little-endian to the assembled code.
func (self *Program) Word(v *expr.Expr) (p *Instruction) {
p = self.pseudo(_PseudoWord)
p.pseudo.expr = v
return
}
// Long is a pseudo-instruction to add raw uint32 as little-endian to the assembled code.
func (self *Program) Long(v *expr.Expr) (p *Instruction) {
p = self.pseudo(_PseudoLong)
p.pseudo.expr = v
return
}
// Quad is a pseudo-instruction to add raw uint64 as little-endian to the assembled code.
func (self *Program) Quad(v *expr.Expr) (p *Instruction) {
p = self.pseudo(_PseudoQuad)
p.pseudo.expr = v
return
}
// Data is a pseudo-instruction to add raw bytes to the assembled code.
func (self *Program) Data(v []byte) (p *Instruction) {
p = self.pseudo(_PseudoData)
p.pseudo.data = v
return
}
// Align is a pseudo-instruction to ensure the PC is aligned to a certain value.
func (self *Program) Align(align uint64, padding *expr.Expr) (p *Instruction) {
p = self.pseudo(_PseudoAlign)
p.pseudo.uint = align
p.pseudo.expr = padding
return
}
/** Program Assembler **/
// Free returns the Program object into pool.
// Any operation performed after Free is undefined behavior.
//
// NOTE: This also frees all the instructions, labels, memory
//
// operands and expressions associated with this program.
func (self *Program) Free() {
self.clear()
//freeProgram(self)
}
// Link pins a label at the current position.
func (self *Program) Link(p *Label) {
if p.Dest != nil {
panic("lable was alreay linked")
} else {
p.Dest = self.pseudo(_PseudoNop)
}
}
// Assemble assembles and links the entire program into machine code.
func (self *Program) Assemble(pc uintptr) (ret []byte) {
orig := pc
next := true
offs := uintptr(0)
/* Pass 0: PC-precompute, assume all labeled branches are far-branches. */
for p := self.head; p != nil; p = p.next {
if p.pc = pc; !isLabel(p.argv[0]) || p.branch == _B_none {
pc += uintptr(p.encode(nil))
} else {
pc += uintptr(self.branchSize(p))
}
}
/* allocate space for the machine code */
nb := int(pc - orig)
ret = make([]byte, 0, nb)
/* Pass 1: adjust all the jumps */
for next {
next = false
offs = uintptr(0)
/* scan all the branches */
for p := self.head; p != nil; p = p.next {
var ok bool
var lb *Label
/* re-calculate the alignment here */
if nb = p.nb; p.pseudo.kind == _PseudoAlign {
p.pc -= offs
offs += uintptr(nb - p.encode(nil))
continue
}
/* adjust the program counter */
p.pc -= offs
lb, ok = p.argv[0].(*Label)
/* only care about labeled far-branches */
if !ok || p.nb == _N_near || p.branch == _B_none {
continue
}
/* calculate the jump offset */
size := self.branchSize(p)
diff := lb.offset(p.pc, size)
/* too far to be a near jump */
if diff > 127 || diff < -128 {
p.nb = size
continue
}
/* a far jump becomes a near jump, calculate
* the PC adjustment value and assemble again */
next = true
p.nb = _N_near
offs += uintptr(size - _N_near)
}
}
/* Pass 3: link all the cross-references */
for p := self.head; p != nil; p = p.next {
for i := 0; i < p.argc; i++ {
var ok bool
var lb *Label
var op *MemoryOperand
/* resolve labels */
if lb, ok = p.argv[i].(*Label); ok {
p.argv[i] = lb.offset(p.pc, p.nb)
continue
}
/* check for memory operands */
if op, ok = p.argv[i].(*MemoryOperand); !ok {
continue
}
/* check for label references */
if op.Addr.Type != Reference {
continue
}
/* replace the label with the real offset */
op.Addr.Type = Offset
op.Addr.Offset = op.Addr.Reference.offset(p.pc, p.nb)
}
}
/* Pass 4: actually encode all the instructions */
for p := self.head; p != nil; p = p.next {
p.encode(&ret)
}
/* all done */
return ret
}
// AssembleAndFree is like Assemble, but it frees the Program after assembling.
func (self *Program) AssembleAndFree(pc uintptr) (ret []byte) {
ret = self.Assemble(pc)
self.Free()
return
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/internal/iasm/x86_64/eface.go | vendor/github.com/bytedance/sonic/loader/internal/iasm/x86_64/eface.go | //
// Copyright 2024 CloudWeGo Authors
//
// 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 x86_64
import (
"reflect"
"unsafe"
)
type _GoType struct {
size uintptr
pdata uintptr
hash uint32
flags uint8
align uint8
falign uint8
kflags uint8
traits unsafe.Pointer
gcdata *byte
str int32
ptrx int32
}
const (
_KindMask = (1 << 5) - 1
)
func (self *_GoType) kind() reflect.Kind {
return reflect.Kind(self.kflags & _KindMask)
}
type _GoSlice struct {
ptr unsafe.Pointer
len int
cap int
}
type _GoEface struct {
vt *_GoType
ptr unsafe.Pointer
}
func (self *_GoEface) kind() reflect.Kind {
if self.vt != nil {
return self.vt.kind()
} else {
return reflect.Invalid
}
}
func (self *_GoEface) toInt64() int64 {
if self.vt.size == 8 {
return *(*int64)(self.ptr)
} else if self.vt.size == 4 {
return int64(*(*int32)(self.ptr))
} else if self.vt.size == 2 {
return int64(*(*int16)(self.ptr))
} else {
return int64(*(*int8)(self.ptr))
}
}
func efaceOf(v interface{}) _GoEface {
return *(*_GoEface)(unsafe.Pointer(&v))
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/internal/iasm/x86_64/instructions.go | vendor/github.com/bytedance/sonic/loader/internal/iasm/x86_64/instructions.go | //
// Copyright 2024 CloudWeGo Authors
//
// 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.
//
// Code generated by "mkasm_amd64.py", DO NOT EDIT.
package x86_64
// ADDQ performs "Add".
//
// Mnemonic : ADD
// Supported forms : (8 forms)
//
// - ADDQ imm32, rax
// - ADDQ imm8, r64
// - ADDQ imm32, r64
// - ADDQ r64, r64
// - ADDQ m64, r64
// - ADDQ imm8, m64
// - ADDQ imm32, m64
// - ADDQ r64, m64
func (self *Program) ADDQ(v0 interface{}, v1 interface{}) *Instruction {
p := self.alloc("ADDQ", 2, Operands{v0, v1})
// ADDQ imm32, rax
if isImm32(v0) && v1 == RAX {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0x48)
m.emit(0x05)
m.imm4(toImmAny(v[0]))
})
}
// ADDQ imm8, r64
if isImm8Ext(v0, 8) && isReg64(v1) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0x48 | hcode(v[1]))
m.emit(0x83)
m.emit(0xc0 | lcode(v[1]))
m.imm1(toImmAny(v[0]))
})
}
// ADDQ imm32, r64
if isImm32Ext(v0, 8) && isReg64(v1) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0x48 | hcode(v[1]))
m.emit(0x81)
m.emit(0xc0 | lcode(v[1]))
m.imm4(toImmAny(v[0]))
})
}
// ADDQ r64, r64
if isReg64(v0) && isReg64(v1) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0x48 | hcode(v[0])<<2 | hcode(v[1]))
m.emit(0x01)
m.emit(0xc0 | lcode(v[0])<<3 | lcode(v[1]))
})
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0x48 | hcode(v[1])<<2 | hcode(v[0]))
m.emit(0x03)
m.emit(0xc0 | lcode(v[1])<<3 | lcode(v[0]))
})
}
// ADDQ m64, r64
if isM64(v0) && isReg64(v1) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.rexm(1, hcode(v[1]), addr(v[0]))
m.emit(0x03)
m.mrsd(lcode(v[1]), addr(v[0]), 1)
})
}
// ADDQ imm8, m64
if isImm8Ext(v0, 8) && isM64(v1) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.rexm(1, 0, addr(v[1]))
m.emit(0x83)
m.mrsd(0, addr(v[1]), 1)
m.imm1(toImmAny(v[0]))
})
}
// ADDQ imm32, m64
if isImm32Ext(v0, 8) && isM64(v1) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.rexm(1, 0, addr(v[1]))
m.emit(0x81)
m.mrsd(0, addr(v[1]), 1)
m.imm4(toImmAny(v[0]))
})
}
// ADDQ r64, m64
if isReg64(v0) && isM64(v1) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.rexm(1, hcode(v[0]), addr(v[1]))
m.emit(0x01)
m.mrsd(lcode(v[0]), addr(v[1]), 1)
})
}
if p.len == 0 {
panic("invalid operands for ADDQ")
}
return p
}
// CALLQ performs "Call Procedure".
//
// Mnemonic : CALL
// Supported forms : (2 forms)
//
// - CALLQ r64
// - CALLQ m64
func (self *Program) CALLQ(v0 interface{}) *Instruction {
p := self.alloc("CALLQ", 1, Operands{v0})
// CALLQ r64
if isReg64(v0) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.rexo(0, v[0], false)
m.emit(0xff)
m.emit(0xd0 | lcode(v[0]))
})
}
// CALLQ m64
if isM64(v0) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.rexo(0, addr(v[0]), false)
m.emit(0xff)
m.mrsd(2, addr(v[0]), 1)
})
}
if p.len == 0 {
panic("invalid operands for CALLQ")
}
return p
}
// CMPQ performs "Compare Two Operands".
//
// Mnemonic : CMP
// Supported forms : (8 forms)
//
// - CMPQ imm32, rax
// - CMPQ imm8, r64
// - CMPQ imm32, r64
// - CMPQ r64, r64
// - CMPQ m64, r64
// - CMPQ imm8, m64
// - CMPQ imm32, m64
// - CMPQ r64, m64
func (self *Program) CMPQ(v0 interface{}, v1 interface{}) *Instruction {
p := self.alloc("CMPQ", 2, Operands{v0, v1})
// CMPQ imm32, rax
if isImm32(v0) && v1 == RAX {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0x48)
m.emit(0x3d)
m.imm4(toImmAny(v[0]))
})
}
// CMPQ imm8, r64
if isImm8Ext(v0, 8) && isReg64(v1) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0x48 | hcode(v[1]))
m.emit(0x83)
m.emit(0xf8 | lcode(v[1]))
m.imm1(toImmAny(v[0]))
})
}
// CMPQ imm32, r64
if isImm32Ext(v0, 8) && isReg64(v1) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0x48 | hcode(v[1]))
m.emit(0x81)
m.emit(0xf8 | lcode(v[1]))
m.imm4(toImmAny(v[0]))
})
}
// CMPQ r64, r64
if isReg64(v0) && isReg64(v1) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0x48 | hcode(v[0])<<2 | hcode(v[1]))
m.emit(0x39)
m.emit(0xc0 | lcode(v[0])<<3 | lcode(v[1]))
})
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0x48 | hcode(v[1])<<2 | hcode(v[0]))
m.emit(0x3b)
m.emit(0xc0 | lcode(v[1])<<3 | lcode(v[0]))
})
}
// CMPQ m64, r64
if isM64(v0) && isReg64(v1) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.rexm(1, hcode(v[1]), addr(v[0]))
m.emit(0x3b)
m.mrsd(lcode(v[1]), addr(v[0]), 1)
})
}
// CMPQ imm8, m64
if isImm8Ext(v0, 8) && isM64(v1) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.rexm(1, 0, addr(v[1]))
m.emit(0x83)
m.mrsd(7, addr(v[1]), 1)
m.imm1(toImmAny(v[0]))
})
}
// CMPQ imm32, m64
if isImm32Ext(v0, 8) && isM64(v1) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.rexm(1, 0, addr(v[1]))
m.emit(0x81)
m.mrsd(7, addr(v[1]), 1)
m.imm4(toImmAny(v[0]))
})
}
// CMPQ r64, m64
if isReg64(v0) && isM64(v1) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.rexm(1, hcode(v[0]), addr(v[1]))
m.emit(0x39)
m.mrsd(lcode(v[0]), addr(v[1]), 1)
})
}
if p.len == 0 {
panic("invalid operands for CMPQ")
}
return p
}
// JBE performs "Jump if below or equal (CF == 1 or ZF == 1)".
//
// Mnemonic : JBE
// Supported forms : (2 forms)
//
// - JBE rel8
// - JBE rel32
func (self *Program) JBE(v0 interface{}) *Instruction {
p := self.alloc("JBE", 1, Operands{v0})
p.branch = _B_conditional
// JBE rel8
if isRel8(v0) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0x76)
m.imm1(relv(v[0]))
})
}
// JBE rel32
if isRel32(v0) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0x0f)
m.emit(0x86)
m.imm4(relv(v[0]))
})
}
// JBE label
if isLabel(v0) {
p.add(_F_rel1, func(m *_Encoding, v []interface{}) {
m.emit(0x76)
m.imm1(relv(v[0]))
})
p.add(_F_rel4, func(m *_Encoding, v []interface{}) {
m.emit(0x0f)
m.emit(0x86)
m.imm4(relv(v[0]))
})
}
if p.len == 0 {
panic("invalid operands for JBE")
}
return p
}
// JMP performs "Jump Unconditionally".
//
// Mnemonic : JMP
// Supported forms : (2 forms)
//
// - JMP rel8
// - JMP rel32
func (self *Program) JMP(v0 interface{}) *Instruction {
p := self.alloc("JMP", 1, Operands{v0})
p.branch = _B_unconditional
// JMP rel8
if isRel8(v0) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0xeb)
m.imm1(relv(v[0]))
})
}
// JMP rel32
if isRel32(v0) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0xe9)
m.imm4(relv(v[0]))
})
}
// JMP label
if isLabel(v0) {
p.add(_F_rel1, func(m *_Encoding, v []interface{}) {
m.emit(0xeb)
m.imm1(relv(v[0]))
})
p.add(_F_rel4, func(m *_Encoding, v []interface{}) {
m.emit(0xe9)
m.imm4(relv(v[0]))
})
}
if p.len == 0 {
panic("invalid operands for JMP")
}
return p
}
// JMPQ performs "Jump Unconditionally".
//
// Mnemonic : JMP
// Supported forms : (2 forms)
//
// - JMPQ r64
// - JMPQ m64
func (self *Program) JMPQ(v0 interface{}) *Instruction {
p := self.alloc("JMPQ", 1, Operands{v0})
// JMPQ r64
if isReg64(v0) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.rexo(0, v[0], false)
m.emit(0xff)
m.emit(0xe0 | lcode(v[0]))
})
}
// JMPQ m64
if isM64(v0) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.rexo(0, addr(v[0]), false)
m.emit(0xff)
m.mrsd(4, addr(v[0]), 1)
})
}
if p.len == 0 {
panic("invalid operands for JMPQ")
}
return p
}
// LEAQ performs "Load Effective Address".
//
// Mnemonic : LEA
// Supported forms : (1 form)
//
// - LEAQ m, r64
func (self *Program) LEAQ(v0 interface{}, v1 interface{}) *Instruction {
p := self.alloc("LEAQ", 2, Operands{v0, v1})
// LEAQ m, r64
if isM(v0) && isReg64(v1) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.rexm(1, hcode(v[1]), addr(v[0]))
m.emit(0x8d)
m.mrsd(lcode(v[1]), addr(v[0]), 1)
})
}
if p.len == 0 {
panic("invalid operands for LEAQ")
}
return p
}
// MOVQ performs "Move".
//
// Mnemonic : MOV
// Supported forms : (16 forms)
//
// - MOVQ imm32, r64
// - MOVQ imm64, r64
// - MOVQ r64, r64
// - MOVQ m64, r64
// - MOVQ imm32, m64
// - MOVQ r64, m64
// - MOVQ mm, r64 [MMX]
// - MOVQ r64, mm [MMX]
// - MOVQ mm, mm [MMX]
// - MOVQ m64, mm [MMX]
// - MOVQ mm, m64 [MMX]
// - MOVQ xmm, r64 [SSE2]
// - MOVQ r64, xmm [SSE2]
// - MOVQ xmm, xmm [SSE2]
// - MOVQ m64, xmm [SSE2]
// - MOVQ xmm, m64 [SSE2]
func (self *Program) MOVQ(v0 interface{}, v1 interface{}) *Instruction {
p := self.alloc("MOVQ", 2, Operands{v0, v1})
// MOVQ imm32, r64
if isImm32Ext(v0, 8) && isReg64(v1) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0x48 | hcode(v[1]))
m.emit(0xc7)
m.emit(0xc0 | lcode(v[1]))
m.imm4(toImmAny(v[0]))
})
}
// MOVQ imm64, r64
if isImm64(v0) && isReg64(v1) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0x48 | hcode(v[1]))
m.emit(0xb8 | lcode(v[1]))
m.imm8(toImmAny(v[0]))
})
}
// MOVQ r64, r64
if isReg64(v0) && isReg64(v1) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0x48 | hcode(v[0])<<2 | hcode(v[1]))
m.emit(0x89)
m.emit(0xc0 | lcode(v[0])<<3 | lcode(v[1]))
})
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0x48 | hcode(v[1])<<2 | hcode(v[0]))
m.emit(0x8b)
m.emit(0xc0 | lcode(v[1])<<3 | lcode(v[0]))
})
}
// MOVQ m64, r64
if isM64(v0) && isReg64(v1) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.rexm(1, hcode(v[1]), addr(v[0]))
m.emit(0x8b)
m.mrsd(lcode(v[1]), addr(v[0]), 1)
})
}
// MOVQ imm32, m64
if isImm32Ext(v0, 8) && isM64(v1) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.rexm(1, 0, addr(v[1]))
m.emit(0xc7)
m.mrsd(0, addr(v[1]), 1)
m.imm4(toImmAny(v[0]))
})
}
// MOVQ r64, m64
if isReg64(v0) && isM64(v1) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.rexm(1, hcode(v[0]), addr(v[1]))
m.emit(0x89)
m.mrsd(lcode(v[0]), addr(v[1]), 1)
})
}
// MOVQ mm, r64
if isMM(v0) && isReg64(v1) {
self.require(ISA_MMX)
p.domain = DomainMMXSSE
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0x48 | hcode(v[0])<<2 | hcode(v[1]))
m.emit(0x0f)
m.emit(0x7e)
m.emit(0xc0 | lcode(v[0])<<3 | lcode(v[1]))
})
}
// MOVQ r64, mm
if isReg64(v0) && isMM(v1) {
self.require(ISA_MMX)
p.domain = DomainMMXSSE
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0x48 | hcode(v[1])<<2 | hcode(v[0]))
m.emit(0x0f)
m.emit(0x6e)
m.emit(0xc0 | lcode(v[1])<<3 | lcode(v[0]))
})
}
// MOVQ mm, mm
if isMM(v0) && isMM(v1) {
self.require(ISA_MMX)
p.domain = DomainMMXSSE
p.add(0, func(m *_Encoding, v []interface{}) {
m.rexo(hcode(v[1]), v[0], false)
m.emit(0x0f)
m.emit(0x6f)
m.emit(0xc0 | lcode(v[1])<<3 | lcode(v[0]))
})
p.add(0, func(m *_Encoding, v []interface{}) {
m.rexo(hcode(v[0]), v[1], false)
m.emit(0x0f)
m.emit(0x7f)
m.emit(0xc0 | lcode(v[0])<<3 | lcode(v[1]))
})
}
// MOVQ m64, mm
if isM64(v0) && isMM(v1) {
self.require(ISA_MMX)
p.domain = DomainMMXSSE
p.add(0, func(m *_Encoding, v []interface{}) {
m.rexo(hcode(v[1]), addr(v[0]), false)
m.emit(0x0f)
m.emit(0x6f)
m.mrsd(lcode(v[1]), addr(v[0]), 1)
})
p.add(0, func(m *_Encoding, v []interface{}) {
m.rexm(1, hcode(v[1]), addr(v[0]))
m.emit(0x0f)
m.emit(0x6e)
m.mrsd(lcode(v[1]), addr(v[0]), 1)
})
}
// MOVQ mm, m64
if isMM(v0) && isM64(v1) {
self.require(ISA_MMX)
p.domain = DomainMMXSSE
p.add(0, func(m *_Encoding, v []interface{}) {
m.rexo(hcode(v[0]), addr(v[1]), false)
m.emit(0x0f)
m.emit(0x7f)
m.mrsd(lcode(v[0]), addr(v[1]), 1)
})
p.add(0, func(m *_Encoding, v []interface{}) {
m.rexm(1, hcode(v[0]), addr(v[1]))
m.emit(0x0f)
m.emit(0x7e)
m.mrsd(lcode(v[0]), addr(v[1]), 1)
})
}
// MOVQ xmm, r64
if isXMM(v0) && isReg64(v1) {
self.require(ISA_SSE2)
p.domain = DomainMMXSSE
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0x66)
m.emit(0x48 | hcode(v[0])<<2 | hcode(v[1]))
m.emit(0x0f)
m.emit(0x7e)
m.emit(0xc0 | lcode(v[0])<<3 | lcode(v[1]))
})
}
// MOVQ r64, xmm
if isReg64(v0) && isXMM(v1) {
self.require(ISA_SSE2)
p.domain = DomainMMXSSE
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0x66)
m.emit(0x48 | hcode(v[1])<<2 | hcode(v[0]))
m.emit(0x0f)
m.emit(0x6e)
m.emit(0xc0 | lcode(v[1])<<3 | lcode(v[0]))
})
}
// MOVQ xmm, xmm
if isXMM(v0) && isXMM(v1) {
self.require(ISA_SSE2)
p.domain = DomainMMXSSE
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0xf3)
m.rexo(hcode(v[1]), v[0], false)
m.emit(0x0f)
m.emit(0x7e)
m.emit(0xc0 | lcode(v[1])<<3 | lcode(v[0]))
})
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0x66)
m.rexo(hcode(v[0]), v[1], false)
m.emit(0x0f)
m.emit(0xd6)
m.emit(0xc0 | lcode(v[0])<<3 | lcode(v[1]))
})
}
// MOVQ m64, xmm
if isM64(v0) && isXMM(v1) {
self.require(ISA_SSE2)
p.domain = DomainMMXSSE
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0xf3)
m.rexo(hcode(v[1]), addr(v[0]), false)
m.emit(0x0f)
m.emit(0x7e)
m.mrsd(lcode(v[1]), addr(v[0]), 1)
})
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0x66)
m.rexm(1, hcode(v[1]), addr(v[0]))
m.emit(0x0f)
m.emit(0x6e)
m.mrsd(lcode(v[1]), addr(v[0]), 1)
})
}
// MOVQ xmm, m64
if isXMM(v0) && isM64(v1) {
self.require(ISA_SSE2)
p.domain = DomainMMXSSE
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0x66)
m.rexo(hcode(v[0]), addr(v[1]), false)
m.emit(0x0f)
m.emit(0xd6)
m.mrsd(lcode(v[0]), addr(v[1]), 1)
})
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0x66)
m.rexm(1, hcode(v[0]), addr(v[1]))
m.emit(0x0f)
m.emit(0x7e)
m.mrsd(lcode(v[0]), addr(v[1]), 1)
})
}
if p.len == 0 {
panic("invalid operands for MOVQ")
}
return p
}
// MOVSD performs "Move Scalar Double-Precision Floating-Point Value".
//
// Mnemonic : MOVSD
// Supported forms : (3 forms)
//
// - MOVSD xmm, xmm [SSE2]
// - MOVSD m64, xmm [SSE2]
// - MOVSD xmm, m64 [SSE2]
func (self *Program) MOVSD(v0 interface{}, v1 interface{}) *Instruction {
p := self.alloc("MOVSD", 2, Operands{v0, v1})
// MOVSD xmm, xmm
if isXMM(v0) && isXMM(v1) {
self.require(ISA_SSE2)
p.domain = DomainMMXSSE
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0xf2)
m.rexo(hcode(v[1]), v[0], false)
m.emit(0x0f)
m.emit(0x10)
m.emit(0xc0 | lcode(v[1])<<3 | lcode(v[0]))
})
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0xf2)
m.rexo(hcode(v[0]), v[1], false)
m.emit(0x0f)
m.emit(0x11)
m.emit(0xc0 | lcode(v[0])<<3 | lcode(v[1]))
})
}
// MOVSD m64, xmm
if isM64(v0) && isXMM(v1) {
self.require(ISA_SSE2)
p.domain = DomainMMXSSE
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0xf2)
m.rexo(hcode(v[1]), addr(v[0]), false)
m.emit(0x0f)
m.emit(0x10)
m.mrsd(lcode(v[1]), addr(v[0]), 1)
})
}
// MOVSD xmm, m64
if isXMM(v0) && isM64(v1) {
self.require(ISA_SSE2)
p.domain = DomainMMXSSE
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0xf2)
m.rexo(hcode(v[0]), addr(v[1]), false)
m.emit(0x0f)
m.emit(0x11)
m.mrsd(lcode(v[0]), addr(v[1]), 1)
})
}
if p.len == 0 {
panic("invalid operands for MOVSD")
}
return p
}
// MOVSLQ performs "Move Doubleword to Quadword with Sign-Extension".
//
// Mnemonic : MOVSXD
// Supported forms : (2 forms)
//
// - MOVSLQ r32, r64
// - MOVSLQ m32, r64
func (self *Program) MOVSLQ(v0 interface{}, v1 interface{}) *Instruction {
p := self.alloc("MOVSLQ", 2, Operands{v0, v1})
// MOVSLQ r32, r64
if isReg32(v0) && isReg64(v1) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0x48 | hcode(v[1])<<2 | hcode(v[0]))
m.emit(0x63)
m.emit(0xc0 | lcode(v[1])<<3 | lcode(v[0]))
})
}
// MOVSLQ m32, r64
if isM32(v0) && isReg64(v1) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.rexm(1, hcode(v[1]), addr(v[0]))
m.emit(0x63)
m.mrsd(lcode(v[1]), addr(v[0]), 1)
})
}
if p.len == 0 {
panic("invalid operands for MOVSLQ")
}
return p
}
// MOVSS performs "Move Scalar Single-Precision Floating-Point Values".
//
// Mnemonic : MOVSS
// Supported forms : (3 forms)
//
// - MOVSS xmm, xmm [SSE]
// - MOVSS m32, xmm [SSE]
// - MOVSS xmm, m32 [SSE]
func (self *Program) MOVSS(v0 interface{}, v1 interface{}) *Instruction {
p := self.alloc("MOVSS", 2, Operands{v0, v1})
// MOVSS xmm, xmm
if isXMM(v0) && isXMM(v1) {
self.require(ISA_SSE)
p.domain = DomainMMXSSE
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0xf3)
m.rexo(hcode(v[1]), v[0], false)
m.emit(0x0f)
m.emit(0x10)
m.emit(0xc0 | lcode(v[1])<<3 | lcode(v[0]))
})
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0xf3)
m.rexo(hcode(v[0]), v[1], false)
m.emit(0x0f)
m.emit(0x11)
m.emit(0xc0 | lcode(v[0])<<3 | lcode(v[1]))
})
}
// MOVSS m32, xmm
if isM32(v0) && isXMM(v1) {
self.require(ISA_SSE)
p.domain = DomainMMXSSE
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0xf3)
m.rexo(hcode(v[1]), addr(v[0]), false)
m.emit(0x0f)
m.emit(0x10)
m.mrsd(lcode(v[1]), addr(v[0]), 1)
})
}
// MOVSS xmm, m32
if isXMM(v0) && isM32(v1) {
self.require(ISA_SSE)
p.domain = DomainMMXSSE
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0xf3)
m.rexo(hcode(v[0]), addr(v[1]), false)
m.emit(0x0f)
m.emit(0x11)
m.mrsd(lcode(v[0]), addr(v[1]), 1)
})
}
if p.len == 0 {
panic("invalid operands for MOVSS")
}
return p
}
// RET performs "Return from Procedure".
//
// Mnemonic : RET
// Supported forms : (2 forms)
//
// - RET
// - RET imm16
func (self *Program) RET(vv ...interface{}) *Instruction {
var p *Instruction
switch len(vv) {
case 0:
p = self.alloc("RET", 0, Operands{})
case 1:
p = self.alloc("RET", 1, Operands{vv[0]})
default:
panic("instruction RET takes 0 or 1 operands")
}
// RET
if len(vv) == 0 {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0xc3)
})
}
// RET imm16
if len(vv) == 1 && isImm16(vv[0]) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0xc2)
m.imm2(toImmAny(v[0]))
})
}
if p.len == 0 {
panic("invalid operands for RET")
}
return p
}
// SUBQ performs "Subtract".
//
// Mnemonic : SUB
// Supported forms : (8 forms)
//
// - SUBQ imm32, rax
// - SUBQ imm8, r64
// - SUBQ imm32, r64
// - SUBQ r64, r64
// - SUBQ m64, r64
// - SUBQ imm8, m64
// - SUBQ imm32, m64
// - SUBQ r64, m64
func (self *Program) SUBQ(v0 interface{}, v1 interface{}) *Instruction {
p := self.alloc("SUBQ", 2, Operands{v0, v1})
// SUBQ imm32, rax
if isImm32(v0) && v1 == RAX {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0x48)
m.emit(0x2d)
m.imm4(toImmAny(v[0]))
})
}
// SUBQ imm8, r64
if isImm8Ext(v0, 8) && isReg64(v1) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0x48 | hcode(v[1]))
m.emit(0x83)
m.emit(0xe8 | lcode(v[1]))
m.imm1(toImmAny(v[0]))
})
}
// SUBQ imm32, r64
if isImm32Ext(v0, 8) && isReg64(v1) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0x48 | hcode(v[1]))
m.emit(0x81)
m.emit(0xe8 | lcode(v[1]))
m.imm4(toImmAny(v[0]))
})
}
// SUBQ r64, r64
if isReg64(v0) && isReg64(v1) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0x48 | hcode(v[0])<<2 | hcode(v[1]))
m.emit(0x29)
m.emit(0xc0 | lcode(v[0])<<3 | lcode(v[1]))
})
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0x48 | hcode(v[1])<<2 | hcode(v[0]))
m.emit(0x2b)
m.emit(0xc0 | lcode(v[1])<<3 | lcode(v[0]))
})
}
// SUBQ m64, r64
if isM64(v0) && isReg64(v1) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.rexm(1, hcode(v[1]), addr(v[0]))
m.emit(0x2b)
m.mrsd(lcode(v[1]), addr(v[0]), 1)
})
}
// SUBQ imm8, m64
if isImm8Ext(v0, 8) && isM64(v1) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.rexm(1, 0, addr(v[1]))
m.emit(0x83)
m.mrsd(5, addr(v[1]), 1)
m.imm1(toImmAny(v[0]))
})
}
// SUBQ imm32, m64
if isImm32Ext(v0, 8) && isM64(v1) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.rexm(1, 0, addr(v[1]))
m.emit(0x81)
m.mrsd(5, addr(v[1]), 1)
m.imm4(toImmAny(v[0]))
})
}
// SUBQ r64, m64
if isReg64(v0) && isM64(v1) {
p.domain = DomainGeneric
p.add(0, func(m *_Encoding, v []interface{}) {
m.rexm(1, hcode(v[0]), addr(v[1]))
m.emit(0x29)
m.mrsd(lcode(v[0]), addr(v[1]), 1)
})
}
if p.len == 0 {
panic("invalid operands for SUBQ")
}
return p
}
// VPERMIL2PD performs "Permute Two-Source Double-Precision Floating-Point Vectors".
//
// Mnemonic : VPERMIL2PD
// Supported forms : (6 forms)
//
// - VPERMIL2PD imm4, xmm, xmm, xmm, xmm [XOP]
// - VPERMIL2PD imm4, m128, xmm, xmm, xmm [XOP]
// - VPERMIL2PD imm4, xmm, m128, xmm, xmm [XOP]
// - VPERMIL2PD imm4, ymm, ymm, ymm, ymm [XOP]
// - VPERMIL2PD imm4, m256, ymm, ymm, ymm [XOP]
// - VPERMIL2PD imm4, ymm, m256, ymm, ymm [XOP]
func (self *Program) VPERMIL2PD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, v4 interface{}) *Instruction {
p := self.alloc("VPERMIL2PD", 5, Operands{v0, v1, v2, v3, v4})
// VPERMIL2PD imm4, xmm, xmm, xmm, xmm
if isImm4(v0) && isXMM(v1) && isXMM(v2) && isXMM(v3) && isXMM(v4) {
self.require(ISA_XOP)
p.domain = DomainAMDSpecific
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0xc4)
m.emit(0xe3 ^ (hcode(v[4]) << 7) ^ (hcode(v[2]) << 5))
m.emit(0x79 ^ (hlcode(v[3]) << 3))
m.emit(0x49)
m.emit(0xc0 | lcode(v[4])<<3 | lcode(v[2]))
m.emit((hlcode(v[1]) << 4) | imml(v[0]))
})
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0xc4)
m.emit(0xe3 ^ (hcode(v[4]) << 7) ^ (hcode(v[1]) << 5))
m.emit(0xf9 ^ (hlcode(v[3]) << 3))
m.emit(0x49)
m.emit(0xc0 | lcode(v[4])<<3 | lcode(v[1]))
m.emit((hlcode(v[2]) << 4) | imml(v[0]))
})
}
// VPERMIL2PD imm4, m128, xmm, xmm, xmm
if isImm4(v0) && isM128(v1) && isXMM(v2) && isXMM(v3) && isXMM(v4) {
self.require(ISA_XOP)
p.domain = DomainAMDSpecific
p.add(0, func(m *_Encoding, v []interface{}) {
m.vex3(0xc4, 0b11, 0x81, hcode(v[4]), addr(v[1]), hlcode(v[3]))
m.emit(0x49)
m.mrsd(lcode(v[4]), addr(v[1]), 1)
m.emit((hlcode(v[2]) << 4) | imml(v[0]))
})
}
// VPERMIL2PD imm4, xmm, m128, xmm, xmm
if isImm4(v0) && isXMM(v1) && isM128(v2) && isXMM(v3) && isXMM(v4) {
self.require(ISA_XOP)
p.domain = DomainAMDSpecific
p.add(0, func(m *_Encoding, v []interface{}) {
m.vex3(0xc4, 0b11, 0x01, hcode(v[4]), addr(v[2]), hlcode(v[3]))
m.emit(0x49)
m.mrsd(lcode(v[4]), addr(v[2]), 1)
m.emit((hlcode(v[1]) << 4) | imml(v[0]))
})
}
// VPERMIL2PD imm4, ymm, ymm, ymm, ymm
if isImm4(v0) && isYMM(v1) && isYMM(v2) && isYMM(v3) && isYMM(v4) {
self.require(ISA_XOP)
p.domain = DomainAMDSpecific
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0xc4)
m.emit(0xe3 ^ (hcode(v[4]) << 7) ^ (hcode(v[2]) << 5))
m.emit(0x7d ^ (hlcode(v[3]) << 3))
m.emit(0x49)
m.emit(0xc0 | lcode(v[4])<<3 | lcode(v[2]))
m.emit((hlcode(v[1]) << 4) | imml(v[0]))
})
p.add(0, func(m *_Encoding, v []interface{}) {
m.emit(0xc4)
m.emit(0xe3 ^ (hcode(v[4]) << 7) ^ (hcode(v[1]) << 5))
m.emit(0xfd ^ (hlcode(v[3]) << 3))
m.emit(0x49)
m.emit(0xc0 | lcode(v[4])<<3 | lcode(v[1]))
m.emit((hlcode(v[2]) << 4) | imml(v[0]))
})
}
// VPERMIL2PD imm4, m256, ymm, ymm, ymm
if isImm4(v0) && isM256(v1) && isYMM(v2) && isYMM(v3) && isYMM(v4) {
self.require(ISA_XOP)
p.domain = DomainAMDSpecific
p.add(0, func(m *_Encoding, v []interface{}) {
m.vex3(0xc4, 0b11, 0x85, hcode(v[4]), addr(v[1]), hlcode(v[3]))
m.emit(0x49)
m.mrsd(lcode(v[4]), addr(v[1]), 1)
m.emit((hlcode(v[2]) << 4) | imml(v[0]))
})
}
// VPERMIL2PD imm4, ymm, m256, ymm, ymm
if isImm4(v0) && isYMM(v1) && isM256(v2) && isYMM(v3) && isYMM(v4) {
self.require(ISA_XOP)
p.domain = DomainAMDSpecific
p.add(0, func(m *_Encoding, v []interface{}) {
m.vex3(0xc4, 0b11, 0x05, hcode(v[4]), addr(v[2]), hlcode(v[3]))
m.emit(0x49)
m.mrsd(lcode(v[4]), addr(v[2]), 1)
m.emit((hlcode(v[1]) << 4) | imml(v[0]))
})
}
if p.len == 0 {
panic("invalid operands for VPERMIL2PD")
}
return p
}
// XORPS performs "Bitwise Logical XOR for Single-Precision Floating-Point Values".
//
// Mnemonic : XORPS
// Supported forms : (2 forms)
//
// - XORPS xmm, xmm [SSE]
// - XORPS m128, xmm [SSE]
func (self *Program) XORPS(v0 interface{}, v1 interface{}) *Instruction {
p := self.alloc("XORPS", 2, Operands{v0, v1})
// XORPS xmm, xmm
if isXMM(v0) && isXMM(v1) {
self.require(ISA_SSE)
p.domain = DomainMMXSSE
p.add(0, func(m *_Encoding, v []interface{}) {
m.rexo(hcode(v[1]), v[0], false)
m.emit(0x0f)
m.emit(0x57)
m.emit(0xc0 | lcode(v[1])<<3 | lcode(v[0]))
})
}
// XORPS m128, xmm
if isM128(v0) && isXMM(v1) {
self.require(ISA_SSE)
p.domain = DomainMMXSSE
p.add(0, func(m *_Encoding, v []interface{}) {
m.rexo(hcode(v[1]), addr(v[0]), false)
m.emit(0x0f)
m.emit(0x57)
m.mrsd(lcode(v[1]), addr(v[0]), 1)
})
}
if p.len == 0 {
panic("invalid operands for XORPS")
}
return p
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/internal/iasm/x86_64/pools.go | vendor/github.com/bytedance/sonic/loader/internal/iasm/x86_64/pools.go | //
// Copyright 2024 CloudWeGo Authors
//
// 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 x86_64
// CreateLabel creates a new Label, it may allocate a new one or grab one from a pool.
func CreateLabel(name string) *Label {
p := new(Label)
/* initialize the label */
p.refs = 1
p.Name = name
return p
}
func newProgram(arch *Arch) *Program {
p := new(Program)
/* initialize the program */
p.arch = arch
return p
}
func newInstruction(name string, argc int, argv Operands) *Instruction {
p := new(Instruction)
/* initialize the instruction */
p.name = name
p.argc = argc
p.argv = argv
return p
}
// CreateMemoryOperand creates a new MemoryOperand, it may allocate a new one or grab one from a pool.
func CreateMemoryOperand() *MemoryOperand {
p := new(MemoryOperand)
/* initialize the memory operand */
p.refs = 1
return p
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/internal/iasm/x86_64/operands.go | vendor/github.com/bytedance/sonic/loader/internal/iasm/x86_64/operands.go | //
// Copyright 2024 CloudWeGo Authors
//
// 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 x86_64
import (
"errors"
"fmt"
"math"
"reflect"
"strconv"
"strings"
"sync/atomic"
)
// RelativeOffset represents an RIP-relative offset.
type RelativeOffset int32
// String implements the fmt.Stringer interface.
func (self RelativeOffset) String() string {
if self == 0 {
return "(%rip)"
} else {
return fmt.Sprintf("%d(%%rip)", self)
}
}
// RoundingControl represents a floating-point rounding option.
type RoundingControl uint8
const (
// RN_SAE represents "Round Nearest", which is the default rounding option.
RN_SAE RoundingControl = iota
// RD_SAE represents "Round Down".
RD_SAE
// RU_SAE represents "Round Up".
RU_SAE
// RZ_SAE represents "Round towards Zero".
RZ_SAE
)
var _RC_NAMES = map[RoundingControl]string{
RN_SAE: "rn-sae",
RD_SAE: "rd-sae",
RU_SAE: "ru-sae",
RZ_SAE: "rz-sae",
}
func (self RoundingControl) String() string {
if v, ok := _RC_NAMES[self]; ok {
return v
} else {
panic("invalid RoundingControl value")
}
}
// ExceptionControl represents the "Suppress All Exceptions" flag.
type ExceptionControl uint8
const (
// SAE represents the flag "Suppress All Exceptions" for floating point operations.
SAE ExceptionControl = iota
)
func (ExceptionControl) String() string {
return "sae"
}
// AddressType indicates which kind of value that an Addressable object contains.
type AddressType uint
const (
// None indicates the Addressable does not contain any addressable value.
None AddressType = iota
// Memory indicates the Addressable contains a memory address.
Memory
// Offset indicates the Addressable contains an RIP-relative offset.
Offset
// Reference indicates the Addressable contains a label reference.
Reference
)
// Disposable is a type of object that can be Free'd manually.
type Disposable interface {
Free()
}
// Label represents a location within the program.
type Label struct {
refs int64
Name string
Dest *Instruction
}
func (self *Label) offset(p uintptr, n int) RelativeOffset {
if self.Dest == nil {
panic("unresolved label: " + self.Name)
} else {
return RelativeOffset(self.Dest.pc - p - uintptr(n))
}
}
// Free decreases the reference count of a Label, if the
// refcount drops to 0, the Label will be recycled.
func (self *Label) Free() {
if atomic.AddInt64(&self.refs, -1) == 0 {
//freeLabel(self)
}
}
// String implements the fmt.Stringer interface.
func (self *Label) String() string {
if self.Dest == nil {
return fmt.Sprintf("%s(%%rip)", self.Name)
} else {
return fmt.Sprintf("%s(%%rip)@%#x", self.Name, self.Dest.pc)
}
}
// Retain increases the reference count of a Label.
func (self *Label) Retain() *Label {
atomic.AddInt64(&self.refs, 1)
return self
}
// Evaluate implements the interface expr.Term.
func (self *Label) Evaluate() (int64, error) {
if self.Dest != nil {
return int64(self.Dest.pc), nil
} else {
return 0, errors.New("unresolved label: " + self.Name)
}
}
// Addressable is a union to represent an addressable operand.
type Addressable struct {
Type AddressType
Memory MemoryAddress
Offset RelativeOffset
Reference *Label
}
// String implements the fmt.Stringer interface.
func (self *Addressable) String() string {
switch self.Type {
case None:
return "(not addressable)"
case Memory:
return self.Memory.String()
case Offset:
return self.Offset.String()
case Reference:
return self.Reference.String()
default:
return "(invalid addressable)"
}
}
// MemoryOperand represents a memory operand for an instruction.
type MemoryOperand struct {
refs int64
Size int
Addr Addressable
Mask RegisterMask
Masked bool
Broadcast uint8
}
const (
_Sizes = 0b10000000100010111 // bit-mask for valid sizes (0, 1, 2, 4, 8, 16)
)
func (self *MemoryOperand) isVMX(evex bool) bool {
return self.Addr.Type == Memory && self.Addr.Memory.isVMX(evex)
}
func (self *MemoryOperand) isVMY(evex bool) bool {
return self.Addr.Type == Memory && self.Addr.Memory.isVMY(evex)
}
func (self *MemoryOperand) isVMZ() bool {
return self.Addr.Type == Memory && self.Addr.Memory.isVMZ()
}
func (self *MemoryOperand) isMem() bool {
if (_Sizes & (1 << self.Broadcast)) == 0 {
return false
} else if self.Addr.Type == Memory {
return self.Addr.Memory.isMem()
} else if self.Addr.Type == Offset {
return true
} else if self.Addr.Type == Reference {
return true
} else {
return false
}
}
func (self *MemoryOperand) isSize(n int) bool {
return self.Size == 0 || self.Size == n
}
func (self *MemoryOperand) isBroadcast(n int, b uint8) bool {
return self.Size == n && self.Broadcast == b
}
func (self *MemoryOperand) formatMask() string {
if !self.Masked {
return ""
} else {
return self.Mask.String()
}
}
func (self *MemoryOperand) formatBroadcast() string {
if self.Broadcast == 0 {
return ""
} else {
return fmt.Sprintf("{1to%d}", self.Broadcast)
}
}
func (self *MemoryOperand) ensureAddrValid() {
switch self.Addr.Type {
case None:
break
case Memory:
self.Addr.Memory.EnsureValid()
case Offset:
break
case Reference:
break
default:
panic("invalid address type")
}
}
func (self *MemoryOperand) ensureSizeValid() {
if (_Sizes & (1 << self.Size)) == 0 {
panic("invalid memory operand size")
}
}
func (self *MemoryOperand) ensureBroadcastValid() {
if (_Sizes & (1 << self.Broadcast)) == 0 {
panic("invalid memory operand broadcast")
}
}
// Free decreases the reference count of a MemoryOperand, if the
// refcount drops to 0, the Label will be recycled.
func (self *MemoryOperand) Free() {
if atomic.AddInt64(&self.refs, -1) == 0 {
//freeMemoryOperand(self)
}
}
// String implements the fmt.Stringer interface.
func (self *MemoryOperand) String() string {
return self.Addr.String() + self.formatMask() + self.formatBroadcast()
}
// Retain increases the reference count of a MemoryOperand.
func (self *MemoryOperand) Retain() *MemoryOperand {
atomic.AddInt64(&self.refs, 1)
return self
}
// EnsureValid checks if the memory operand is valid, if not, it panics.
func (self *MemoryOperand) EnsureValid() {
self.ensureAddrValid()
self.ensureSizeValid()
self.ensureBroadcastValid()
}
// MemoryAddress represents a memory address.
type MemoryAddress struct {
Base Register
Index Register
Scale uint8
Displacement int32
}
const (
_Scales = 0b100010111 // bit-mask for valid scales (0, 1, 2, 4, 8)
)
func (self *MemoryAddress) isVMX(evex bool) bool {
return self.isMemBase() && (self.Index == nil || isXMM(self.Index) || (evex && isEVEXXMM(self.Index)))
}
func (self *MemoryAddress) isVMY(evex bool) bool {
return self.isMemBase() && (self.Index == nil || isYMM(self.Index) || (evex && isEVEXYMM(self.Index)))
}
func (self *MemoryAddress) isVMZ() bool {
return self.isMemBase() && (self.Index == nil || isZMM(self.Index))
}
func (self *MemoryAddress) isMem() bool {
return self.isMemBase() && (self.Index == nil || isReg64(self.Index))
}
func (self *MemoryAddress) isMemBase() bool {
return (self.Base == nil || isReg64(self.Base)) && // `Base` must be 64-bit if present
(self.Scale == 0) == (self.Index == nil) && // `Scale` and `Index` depends on each other
(_Scales&(1<<self.Scale)) != 0 // `Scale` can only be 0, 1, 2, 4 or 8
}
// String implements the fmt.Stringer interface.
func (self *MemoryAddress) String() string {
var dp int
var sb strings.Builder
/* the displacement part */
if dp = int(self.Displacement); dp != 0 {
sb.WriteString(strconv.Itoa(dp))
}
/* the base register */
if sb.WriteByte('('); self.Base != nil {
sb.WriteByte('%')
sb.WriteString(self.Base.String())
}
/* index is optional */
if self.Index != nil {
sb.WriteString(",%")
sb.WriteString(self.Index.String())
/* scale is also optional */
if self.Scale >= 2 {
sb.WriteByte(',')
sb.WriteString(strconv.Itoa(int(self.Scale)))
}
}
/* close the bracket */
sb.WriteByte(')')
return sb.String()
}
// EnsureValid checks if the memory address is valid, if not, it panics.
func (self *MemoryAddress) EnsureValid() {
if !self.isMemBase() || (self.Index != nil && !isIndexable(self.Index)) {
panic("not a valid memory address")
}
}
// Ref constructs a memory reference to a label.
func Ref(ref *Label) (v *MemoryOperand) {
v = CreateMemoryOperand()
v.Addr.Type = Reference
v.Addr.Reference = ref
return
}
// Abs construct a simple memory address that represents absolute addressing.
func Abs(disp int32) *MemoryOperand {
return Sib(nil, nil, 0, disp)
}
// Ptr constructs a simple memory operand with base and displacement.
func Ptr(base Register, disp int32) *MemoryOperand {
return Sib(base, nil, 0, disp)
}
// Sib constructs a simple memory operand that represents a complete memory address.
func Sib(base Register, index Register, scale uint8, disp int32) (v *MemoryOperand) {
v = CreateMemoryOperand()
v.Addr.Type = Memory
v.Addr.Memory.Base = base
v.Addr.Memory.Index = index
v.Addr.Memory.Scale = scale
v.Addr.Memory.Displacement = disp
v.EnsureValid()
return
}
/** Operand Matching Helpers **/
const _IntMask = (1 << reflect.Int) |
(1 << reflect.Int8) |
(1 << reflect.Int16) |
(1 << reflect.Int32) |
(1 << reflect.Int64) |
(1 << reflect.Uint) |
(1 << reflect.Uint8) |
(1 << reflect.Uint16) |
(1 << reflect.Uint32) |
(1 << reflect.Uint64) |
(1 << reflect.Uintptr)
func isInt(k reflect.Kind) bool {
return (_IntMask & (1 << k)) != 0
}
func asInt64(v interface{}) (int64, bool) {
if isSpecial(v) {
return 0, false
} else if x := efaceOf(v); isInt(x.kind()) {
return x.toInt64(), true
} else {
return 0, false
}
}
func inRange(v interface{}, low int64, high int64) bool {
x, ok := asInt64(v)
return ok && x >= low && x <= high
}
func isSpecial(v interface{}) bool {
switch v.(type) {
case Register8:
return true
case Register16:
return true
case Register32:
return true
case Register64:
return true
case KRegister:
return true
case MMRegister:
return true
case XMMRegister:
return true
case YMMRegister:
return true
case ZMMRegister:
return true
case RelativeOffset:
return true
case RoundingControl:
return true
case ExceptionControl:
return true
default:
return false
}
}
func isIndexable(v interface{}) bool {
return isZMM(v) || isReg64(v) || isEVEXXMM(v) || isEVEXYMM(v)
}
func isImm4(v interface{}) bool { return inRange(v, 0, 15) }
func isImm8(v interface{}) bool { return inRange(v, math.MinInt8, math.MaxUint8) }
func isImm16(v interface{}) bool { return inRange(v, math.MinInt16, math.MaxUint16) }
func isImm32(v interface{}) bool { return inRange(v, math.MinInt32, math.MaxUint32) }
func isImm64(v interface{}) bool { _, r := asInt64(v); return r }
func isConst1(v interface{}) bool { x, r := asInt64(v); return r && x == 1 }
func isConst3(v interface{}) bool { x, r := asInt64(v); return r && x == 3 }
func isRel8(v interface{}) bool {
x, r := v.(RelativeOffset)
return r && x >= math.MinInt8 && x <= math.MaxInt8
}
func isRel32(v interface{}) bool { _, r := v.(RelativeOffset); return r }
func isLabel(v interface{}) bool { _, r := v.(*Label); return r }
func isReg8(v interface{}) bool { _, r := v.(Register8); return r }
func isReg8REX(v interface{}) bool {
x, r := v.(Register8)
return r && (x&0x80) == 0 && x >= SPL
}
func isReg16(v interface{}) bool { _, r := v.(Register16); return r }
func isReg32(v interface{}) bool { _, r := v.(Register32); return r }
func isReg64(v interface{}) bool { _, r := v.(Register64); return r }
func isMM(v interface{}) bool { _, r := v.(MMRegister); return r }
func isXMM(v interface{}) bool { x, r := v.(XMMRegister); return r && x <= XMM15 }
func isEVEXXMM(v interface{}) bool { _, r := v.(XMMRegister); return r }
func isXMMk(v interface{}) bool {
x, r := v.(MaskedRegister)
return isXMM(v) || (r && isXMM(x.Reg) && !x.Mask.Z)
}
func isXMMkz(v interface{}) bool {
x, r := v.(MaskedRegister)
return isXMM(v) || (r && isXMM(x.Reg))
}
func isYMM(v interface{}) bool { x, r := v.(YMMRegister); return r && x <= YMM15 }
func isEVEXYMM(v interface{}) bool { _, r := v.(YMMRegister); return r }
func isYMMk(v interface{}) bool {
x, r := v.(MaskedRegister)
return isYMM(v) || (r && isYMM(x.Reg) && !x.Mask.Z)
}
func isYMMkz(v interface{}) bool {
x, r := v.(MaskedRegister)
return isYMM(v) || (r && isYMM(x.Reg))
}
func isZMM(v interface{}) bool { _, r := v.(ZMMRegister); return r }
func isZMMk(v interface{}) bool {
x, r := v.(MaskedRegister)
return isZMM(v) || (r && isZMM(x.Reg) && !x.Mask.Z)
}
func isZMMkz(v interface{}) bool {
x, r := v.(MaskedRegister)
return isZMM(v) || (r && isZMM(x.Reg))
}
func isK(v interface{}) bool { _, r := v.(KRegister); return r }
func isKk(v interface{}) bool {
x, r := v.(MaskedRegister)
return isK(v) || (r && isK(x.Reg) && !x.Mask.Z)
}
func isM(v interface{}) bool {
x, r := v.(*MemoryOperand)
return r && x.isMem() && x.Broadcast == 0 && !x.Masked
}
func isMk(v interface{}) bool {
x, r := v.(*MemoryOperand)
return r && x.isMem() && x.Broadcast == 0 && !(x.Masked && x.Mask.Z)
}
func isMkz(v interface{}) bool {
x, r := v.(*MemoryOperand)
return r && x.isMem() && x.Broadcast == 0
}
func isM8(v interface{}) bool {
x, r := v.(*MemoryOperand)
return r && isM(v) && x.isSize(1)
}
func isM16(v interface{}) bool {
x, r := v.(*MemoryOperand)
return r && isM(v) && x.isSize(2)
}
func isM16kz(v interface{}) bool {
x, r := v.(*MemoryOperand)
return r && isMkz(v) && x.isSize(2)
}
func isM32(v interface{}) bool {
x, r := v.(*MemoryOperand)
return r && isM(v) && x.isSize(4)
}
func isM32k(v interface{}) bool {
x, r := v.(*MemoryOperand)
return r && isMk(v) && x.isSize(4)
}
func isM32kz(v interface{}) bool {
x, r := v.(*MemoryOperand)
return r && isMkz(v) && x.isSize(4)
}
func isM64(v interface{}) bool {
x, r := v.(*MemoryOperand)
return r && isM(v) && x.isSize(8)
}
func isM64k(v interface{}) bool {
x, r := v.(*MemoryOperand)
return r && isMk(v) && x.isSize(8)
}
func isM64kz(v interface{}) bool {
x, r := v.(*MemoryOperand)
return r && isMkz(v) && x.isSize(8)
}
func isM128(v interface{}) bool {
x, r := v.(*MemoryOperand)
return r && isM(v) && x.isSize(16)
}
func isM128kz(v interface{}) bool {
x, r := v.(*MemoryOperand)
return r && isMkz(v) && x.isSize(16)
}
func isM256(v interface{}) bool {
x, r := v.(*MemoryOperand)
return r && isM(v) && x.isSize(32)
}
func isM256kz(v interface{}) bool {
x, r := v.(*MemoryOperand)
return r && isMkz(v) && x.isSize(32)
}
func isM512(v interface{}) bool {
x, r := v.(*MemoryOperand)
return r && isM(v) && x.isSize(64)
}
func isM512kz(v interface{}) bool {
x, r := v.(*MemoryOperand)
return r && isMkz(v) && x.isSize(64)
}
func isM64M32bcst(v interface{}) bool {
x, r := v.(*MemoryOperand)
return isM64(v) || (r && x.isBroadcast(4, 2))
}
func isM128M32bcst(v interface{}) bool {
x, r := v.(*MemoryOperand)
return isM128(v) || (r && x.isBroadcast(4, 4))
}
func isM256M32bcst(v interface{}) bool {
x, r := v.(*MemoryOperand)
return isM256(v) || (r && x.isBroadcast(4, 8))
}
func isM512M32bcst(v interface{}) bool {
x, r := v.(*MemoryOperand)
return isM512(v) || (r && x.isBroadcast(4, 16))
}
func isM128M64bcst(v interface{}) bool {
x, r := v.(*MemoryOperand)
return isM128(v) || (r && x.isBroadcast(8, 2))
}
func isM256M64bcst(v interface{}) bool {
x, r := v.(*MemoryOperand)
return isM256(v) || (r && x.isBroadcast(8, 4))
}
func isM512M64bcst(v interface{}) bool {
x, r := v.(*MemoryOperand)
return isM512(v) || (r && x.isBroadcast(8, 8))
}
func isVMX(v interface{}) bool {
x, r := v.(*MemoryOperand)
return r && x.isVMX(false) && !x.Masked
}
func isEVEXVMX(v interface{}) bool {
x, r := v.(*MemoryOperand)
return r && x.isVMX(true) && !x.Masked
}
func isVMXk(v interface{}) bool { x, r := v.(*MemoryOperand); return r && x.isVMX(true) }
func isVMY(v interface{}) bool {
x, r := v.(*MemoryOperand)
return r && x.isVMY(false) && !x.Masked
}
func isEVEXVMY(v interface{}) bool {
x, r := v.(*MemoryOperand)
return r && x.isVMY(true) && !x.Masked
}
func isVMYk(v interface{}) bool { x, r := v.(*MemoryOperand); return r && x.isVMY(true) }
func isVMZ(v interface{}) bool {
x, r := v.(*MemoryOperand)
return r && x.isVMZ() && !x.Masked
}
func isVMZk(v interface{}) bool { x, r := v.(*MemoryOperand); return r && x.isVMZ() }
func isSAE(v interface{}) bool { _, r := v.(ExceptionControl); return r }
func isER(v interface{}) bool { _, r := v.(RoundingControl); return r }
func isImmExt(v interface{}, ext int, min int64, max int64) bool {
if x, ok := asInt64(v); !ok {
return false
} else if m := int64(1) << (8 * ext); x < m && x >= m+min {
return true
} else {
return x <= max && x >= min
}
}
func isImm8Ext(v interface{}, ext int) bool {
return isImmExt(v, ext, math.MinInt8, math.MaxInt8)
}
func isImm32Ext(v interface{}, ext int) bool {
return isImmExt(v, ext, math.MinInt32, math.MaxInt32)
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/internal/abi/abi.go | vendor/github.com/bytedance/sonic/loader/internal/abi/abi.go | /*
* Copyright 2022 ByteDance Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package abi
import (
`fmt`
`reflect`
`sort`
`strings`
`github.com/bytedance/sonic/loader/internal/rt`
)
type FunctionLayout struct {
FP uint32
Args []Parameter
Rets []Parameter
}
func (self FunctionLayout) String() string {
return self.formatFn()
}
func (self FunctionLayout) ArgSize() uint32 {
size := uintptr(0)
for _, arg := range self.Args {
size += arg.Type.Size()
}
return uint32(size)
}
type slot struct {
p bool
m uint32
}
func (self FunctionLayout) StackMap() *rt.StackMap {
var st []slot
var mb rt.StackMapBuilder
/* add arguments */
for _, v := range self.Args {
st = append(st, slot {
m: v.Mem,
p: v.IsPointer,
})
}
/* add stack-passed return values */
for _, v := range self.Rets {
if !v.InRegister {
st = append(st, slot {
m: v.Mem,
p: v.IsPointer,
})
}
}
/* sort by memory offset */
sort.Slice(st, func(i int, j int) bool {
return st[i].m < st[j].m
})
/* add the bits */
for _, v := range st {
mb.AddField(v.p)
}
/* build the stack map */
return mb.Build()
}
func (self FunctionLayout) formatFn() string {
fp := self.FP
return fmt.Sprintf("\n%#04x\nRets:\n%s\nArgs:\n%s", fp, self.formatSeq(self.Rets, &fp), self.formatSeq(self.Args, &fp))
}
func (self FunctionLayout) formatSeq(v []Parameter, fp *uint32) string {
nb := len(v)
mm := make([]string, 0, len(v))
/* convert each part */
for i := nb-1; i >=0; i-- {
*fp -= PtrSize
mm = append(mm, fmt.Sprintf("%#04x %s", *fp, v[i].String()))
}
/* join them together */
return strings.Join(mm, "\n")
}
type Frame struct {
desc *FunctionLayout
locals []bool
ccall bool
}
func NewFrame(desc *FunctionLayout, locals []bool, ccall bool) Frame {
fr := Frame{}
fr.desc = desc
fr.locals = locals
fr.ccall = ccall
return fr
}
func (self *Frame) String() string {
out := self.desc.String()
off := -8
out += fmt.Sprintf("\n%#4x [Return PC]", off)
off -= 8
out += fmt.Sprintf("\n%#4x [RBP]", off)
off -= 8
for _, v := range ReservedRegs(self.ccall) {
out += fmt.Sprintf("\n%#4x [%v]", off, v)
off -= PtrSize
}
for _, b := range self.locals {
out += fmt.Sprintf("\n%#4x [%v]", off, b)
off -= PtrSize
}
return out
}
func (self *Frame) Prev() uint32 {
return self.Size() + PtrSize
}
func (self *Frame) Size() uint32 {
return uint32(self.Offs() + PtrSize)
}
func (self *Frame) Offs() uint32 {
return uint32(len(ReservedRegs(self.ccall)) * PtrSize + len(self.locals)*PtrSize)
}
func (self *Frame) ArgPtrs() *rt.StackMap {
return self.desc.StackMap()
}
func (self *Frame) LocalPtrs() *rt.StackMap {
var m rt.StackMapBuilder
for _, b := range self.locals {
m.AddFields(len(ReservedRegs(self.ccall)), b)
}
return m.Build()
}
func alignUp(n uint32, a int) uint32 {
return (uint32(n) + uint32(a) - 1) &^ (uint32(a) - 1)
}
func isPointer(vt reflect.Type) bool {
switch vt.Kind() {
case reflect.Bool : fallthrough
case reflect.Int : fallthrough
case reflect.Int8 : fallthrough
case reflect.Int16 : fallthrough
case reflect.Int32 : fallthrough
case reflect.Int64 : fallthrough
case reflect.Uint : fallthrough
case reflect.Uint8 : fallthrough
case reflect.Uint16 : fallthrough
case reflect.Uint32 : fallthrough
case reflect.Uint64 : fallthrough
case reflect.Float32 : fallthrough
case reflect.Float64 : fallthrough
case reflect.Uintptr : return false
case reflect.Chan : fallthrough
case reflect.Func : fallthrough
case reflect.Map : fallthrough
case reflect.Ptr : fallthrough
case reflect.UnsafePointer : return true
case reflect.Complex64 : fallthrough
case reflect.Complex128 : fallthrough
case reflect.Array : fallthrough
case reflect.Struct : panic("abi: unsupported types")
default : panic("abi: invalid value type")
}
} | go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/internal/abi/abi_amd64.go | vendor/github.com/bytedance/sonic/loader/internal/abi/abi_amd64.go | /*
* Copyright 2022 ByteDance Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package abi
import (
"fmt"
"reflect"
"unsafe"
x64 "github.com/bytedance/sonic/loader/internal/iasm/x86_64"
)
type (
Register = x64.Register
Register64 = x64.Register64
XMMRegister = x64.XMMRegister
Program = x64.Program
MemoryOperand = x64.MemoryOperand
Label = x64.Label
)
var (
Ptr = x64.Ptr
DefaultArch = x64.DefaultArch
CreateLabel = x64.CreateLabel
)
const (
RAX = x64.RAX
RSP = x64.RSP
RBP = x64.RBP
R12 = x64.R12
R14 = x64.R14
R15 = x64.R15
)
const (
PtrSize = 8 // pointer size
PtrAlign = 8 // pointer alignment
)
var iregOrderC = []Register{
x64.RDI,
x64.RSI,
x64.RDX,
x64.RCX,
x64.R8,
x64.R9,
}
var xregOrderC = []Register{
x64.XMM0,
x64.XMM1,
x64.XMM2,
x64.XMM3,
x64.XMM4,
x64.XMM5,
x64.XMM6,
x64.XMM7,
}
var (
intType = reflect.TypeOf(0)
ptrType = reflect.TypeOf(unsafe.Pointer(nil))
)
func (self *Frame) argv(i int) *MemoryOperand {
return Ptr(RSP, int32(self.Prev()+self.desc.Args[i].Mem))
}
// spillv is used for growstack spill registers
func (self *Frame) spillv(i int) *MemoryOperand {
// remain one slot for caller return pc
return Ptr(RSP, PtrSize+int32(self.desc.Args[i].Mem))
}
func (self *Frame) retv(i int) *MemoryOperand {
return Ptr(RSP, int32(self.Prev()+self.desc.Rets[i].Mem))
}
func (self *Frame) resv(i int) *MemoryOperand {
return Ptr(RSP, int32(self.Offs()-uint32((i+1)*PtrSize)))
}
func (self *Frame) emitGrowStack(p *Program, entry *Label) {
// spill all register arguments
for i, v := range self.desc.Args {
if v.InRegister {
if v.IsFloat == floatKind64 {
p.MOVSD(v.Reg, self.spillv(i))
} else if v.IsFloat == floatKind32 {
p.MOVSS(v.Reg, self.spillv(i))
} else {
p.MOVQ(v.Reg, self.spillv(i))
}
}
}
// call runtime.morestack_noctxt
p.MOVQ(F_morestack_noctxt, R12)
p.CALLQ(R12)
// load all register arguments
for i, v := range self.desc.Args {
if v.InRegister {
if v.IsFloat == floatKind64 {
p.MOVSD(self.spillv(i), v.Reg)
} else if v.IsFloat == floatKind32 {
p.MOVSS(self.spillv(i), v.Reg)
} else {
p.MOVQ(self.spillv(i), v.Reg)
}
}
}
// jump back to the function entry
p.JMP(entry)
}
func (self *Frame) GrowStackTextSize() uint32 {
p := DefaultArch.CreateProgram()
// spill all register arguments
for i, v := range self.desc.Args {
if v.InRegister {
if v.IsFloat == floatKind64 {
p.MOVSD(v.Reg, self.spillv(i))
} else if v.IsFloat == floatKind32 {
p.MOVSS(v.Reg, self.spillv(i))
} else {
p.MOVQ(v.Reg, self.spillv(i))
}
}
}
// call runtime.morestack_noctxt
p.MOVQ(F_morestack_noctxt, R12)
p.CALLQ(R12)
// load all register arguments
for i, v := range self.desc.Args {
if v.InRegister {
if v.IsFloat == floatKind64 {
p.MOVSD(self.spillv(i), v.Reg)
} else if v.IsFloat == floatKind32 {
p.MOVSS(self.spillv(i), v.Reg)
} else {
p.MOVQ(self.spillv(i), v.Reg)
}
}
}
// jump back to the function entry
l := CreateLabel("")
p.Link(l)
p.JMP(l)
return uint32(len(p.Assemble(0)))
}
func (self *Frame) emitPrologue(p *Program) {
p.SUBQ(self.Size(), RSP)
p.MOVQ(RBP, Ptr(RSP, int32(self.Offs())))
p.LEAQ(Ptr(RSP, int32(self.Offs())), RBP)
}
func (self *Frame) emitEpilogue(p *Program) {
p.MOVQ(Ptr(RSP, int32(self.Offs())), RBP)
p.ADDQ(self.Size(), RSP)
p.RET()
}
func (self *Frame) emitReserveRegs(p *Program) {
// spill reserved registers
for i, r := range ReservedRegs(self.ccall) {
switch r.(type) {
case Register64:
p.MOVQ(r, self.resv(i))
case XMMRegister:
p.MOVSD(r, self.resv(i))
default:
panic(fmt.Sprintf("unsupported register type %t to reserve", r))
}
}
}
func (self *Frame) emitSpillPtrs(p *Program) {
// spill pointer argument registers
for i, r := range self.desc.Args {
if r.InRegister && r.IsPointer {
p.MOVQ(r.Reg, self.argv(i))
}
}
}
func (self *Frame) emitClearPtrs(p *Program) {
// spill pointer argument registers
for i, r := range self.desc.Args {
if r.InRegister && r.IsPointer {
p.MOVQ(int64(0), self.argv(i))
}
}
}
func (self *Frame) emitCallC(p *Program, addr uintptr) {
p.MOVQ(addr, RAX)
p.CALLQ(RAX)
}
type floatKind uint8
const (
notFloatKind floatKind = iota
floatKind32
floatKind64
)
type Parameter struct {
InRegister bool
IsPointer bool
IsFloat floatKind
Reg Register
Mem uint32
Type reflect.Type
}
func mkIReg(vt reflect.Type, reg Register64) (p Parameter) {
p.Reg = reg
p.Type = vt
p.InRegister = true
p.IsPointer = isPointer(vt)
return
}
func isFloat(vt reflect.Type) floatKind {
switch vt.Kind() {
case reflect.Float32:
return floatKind32
case reflect.Float64:
return floatKind64
default:
return notFloatKind
}
}
func mkXReg(vt reflect.Type, reg XMMRegister) (p Parameter) {
p.Reg = reg
p.Type = vt
p.InRegister = true
p.IsFloat = isFloat(vt)
return
}
func mkStack(vt reflect.Type, mem uint32) (p Parameter) {
p.Mem = mem
p.Type = vt
p.InRegister = false
p.IsPointer = isPointer(vt)
p.IsFloat = isFloat(vt)
return
}
func (self Parameter) String() string {
if self.InRegister {
return fmt.Sprintf("[%%%s, Pointer(%v), Float(%v)]", self.Reg, self.IsPointer, self.IsFloat)
} else {
return fmt.Sprintf("[%d(FP), Pointer(%v), Float(%v)]", self.Mem, self.IsPointer, self.IsFloat)
}
}
func CallC(addr uintptr, fr Frame, maxStack uintptr) []byte {
p := DefaultArch.CreateProgram()
stack := CreateLabel("_stack_grow")
entry := CreateLabel("_entry")
p.Link(entry)
fr.emitStackCheck(p, stack, maxStack)
fr.emitPrologue(p)
fr.emitReserveRegs(p)
fr.emitSpillPtrs(p)
fr.emitExchangeArgs(p)
fr.emitCallC(p, addr)
fr.emitExchangeRets(p)
fr.emitRestoreRegs(p)
fr.emitEpilogue(p)
p.Link(stack)
fr.emitGrowStack(p, entry)
return p.Assemble(0)
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/internal/abi/abi_regabi_amd64.go | vendor/github.com/bytedance/sonic/loader/internal/abi/abi_regabi_amd64.go | //go:build go1.17
// +build go1.17
/*
* 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.
*/
/** Go Internal ABI implementation
*
* This module implements the function layout algorithm described by the Go internal ABI.
* See https://github.com/golang/go/blob/master/src/cmd/compile/abi-internal.md for more info.
*/
package abi
import (
"fmt"
"reflect"
x64 "github.com/bytedance/sonic/loader/internal/iasm/x86_64"
)
/** Frame Structure of the Generated Function
FP +------------------------------+
| . . . |
| 2nd reg argument spill space |
+ 1st reg argument spill space |
| <pointer-sized alignment> |
| . . . |
| 2nd stack-assigned result |
+ 1st stack-assigned result |
| <pointer-sized alignment> |
| . . . |
| 2nd stack-assigned argument |
| 1st stack-assigned argument |
| stack-assigned receiver |
prev() +------------------------------+ (Previous Frame)
Return PC |
size() -------------------------------|
Saved RBP |
offs() -------------------------------|
1th Reserved Registers |
-------------------------------|
2th Reserved Registers |
-------------------------------|
Local Variables |
RSP -------------------------------|↓ lower addresses
*/
const zeroRegGo = x64.XMM15
var iregOrderGo = [...]Register64{
x64.RAX, // RDI
x64.RBX, // RSI
x64.RCX, // RDX
x64.RDI, // RCX
x64.RSI, // R8
x64.R8, // R9
x64.R9,
x64.R10,
x64.R11,
}
var xregOrderGo = [...]XMMRegister{
x64.XMM0,
x64.XMM1,
x64.XMM2,
x64.XMM3,
x64.XMM4,
x64.XMM5,
x64.XMM6,
x64.XMM7,
x64.XMM8,
x64.XMM9,
x64.XMM10,
x64.XMM11,
x64.XMM12,
x64.XMM13,
x64.XMM14,
}
func ReservedRegs(callc bool) []Register {
if callc {
return nil
}
return []Register{
R14, // current goroutine
R15, // GOT reference
}
}
type stackAlloc struct {
s uint32
i int
x int
}
func (self *stackAlloc) reset() {
self.i, self.x = 0, 0
}
func (self *stackAlloc) ireg(vt reflect.Type) (p Parameter) {
p = mkIReg(vt, iregOrderGo[self.i])
self.i++
return
}
func (self *stackAlloc) xreg(vt reflect.Type) (p Parameter) {
p = mkXReg(vt, xregOrderGo[self.x])
self.x++
return
}
func (self *stackAlloc) stack(vt reflect.Type) (p Parameter) {
p = mkStack(vt, self.s)
self.s += uint32(vt.Size())
return
}
func (self *stackAlloc) spill(n uint32, a int) uint32 {
self.s = alignUp(self.s, a) + n
return self.s
}
func (self *stackAlloc) alloc(p []Parameter, vt reflect.Type) []Parameter {
nb := vt.Size()
vk := vt.Kind()
/* zero-sized objects are allocated on stack */
if nb == 0 {
return append(p, mkStack(intType, self.s))
}
/* check for value type */
switch vk {
case reflect.Bool:
return self.valloc(p, reflect.TypeOf(false))
case reflect.Int:
return self.valloc(p, intType)
case reflect.Int8:
return self.valloc(p, reflect.TypeOf(int8(0)))
case reflect.Int16:
return self.valloc(p, reflect.TypeOf(int16(0)))
case reflect.Int32:
return self.valloc(p, reflect.TypeOf(uint32(0)))
case reflect.Int64:
return self.valloc(p, reflect.TypeOf(int64(0)))
case reflect.Uint:
return self.valloc(p, reflect.TypeOf(uint(0)))
case reflect.Uint8:
return self.valloc(p, reflect.TypeOf(uint8(0)))
case reflect.Uint16:
return self.valloc(p, reflect.TypeOf(uint16(0)))
case reflect.Uint32:
return self.valloc(p, reflect.TypeOf(uint32(0)))
case reflect.Uint64:
return self.valloc(p, reflect.TypeOf(uint64(0)))
case reflect.Uintptr:
return self.valloc(p, reflect.TypeOf(uintptr(0)))
case reflect.Float32:
return self.valloc(p, reflect.TypeOf(float32(0)))
case reflect.Float64:
return self.valloc(p, reflect.TypeOf(float64(0)))
case reflect.Complex64:
panic("abi: go117: not implemented: complex64")
case reflect.Complex128:
panic("abi: go117: not implemented: complex128")
case reflect.Array:
panic("abi: go117: not implemented: arrays")
case reflect.Chan:
return self.valloc(p, reflect.TypeOf((chan int)(nil)))
case reflect.Func:
return self.valloc(p, reflect.TypeOf((func())(nil)))
case reflect.Map:
return self.valloc(p, reflect.TypeOf((map[int]int)(nil)))
case reflect.Ptr:
return self.valloc(p, reflect.TypeOf((*int)(nil)))
case reflect.UnsafePointer:
return self.valloc(p, ptrType)
case reflect.Interface:
return self.valloc(p, ptrType, ptrType)
case reflect.Slice:
return self.valloc(p, ptrType, intType, intType)
case reflect.String:
return self.valloc(p, ptrType, intType)
case reflect.Struct:
panic("abi: go117: not implemented: structs")
default:
panic("abi: invalid value type")
}
}
func (self *stackAlloc) valloc(p []Parameter, vts ...reflect.Type) []Parameter {
for _, vt := range vts {
enum := isFloat(vt)
if enum != notFloatKind && self.x < len(xregOrderGo) {
p = append(p, self.xreg(vt))
} else if enum == notFloatKind && self.i < len(iregOrderGo) {
p = append(p, self.ireg(vt))
} else {
p = append(p, self.stack(vt))
}
}
return p
}
func NewFunctionLayout(ft reflect.Type) FunctionLayout {
var sa stackAlloc
var fn FunctionLayout
/* assign every arguments */
for i := 0; i < ft.NumIn(); i++ {
fn.Args = sa.alloc(fn.Args, ft.In(i))
}
/* reset the register counter, and add a pointer alignment field */
sa.reset()
/* assign every return value */
for i := 0; i < ft.NumOut(); i++ {
fn.Rets = sa.alloc(fn.Rets, ft.Out(i))
}
sa.spill(0, PtrAlign)
/* assign spill slots */
for i := 0; i < len(fn.Args); i++ {
if fn.Args[i].InRegister {
fn.Args[i].Mem = sa.spill(PtrSize, PtrAlign) - PtrSize
}
}
/* add the final pointer alignment field */
fn.FP = sa.spill(0, PtrAlign)
return fn
}
func (self *Frame) emitExchangeArgs(p *Program) {
iregArgs := make([]Parameter, 0, len(self.desc.Args))
xregArgs := 0
for _, v := range self.desc.Args {
if v.InRegister {
if v.IsFloat != notFloatKind {
xregArgs += 1
} else {
iregArgs = append(iregArgs, v)
}
} else {
panic("not support stack-assgined arguments now")
}
}
if xregArgs > len(xregOrderC) {
panic("too many arguments, only support at most 8 integer register arguments now")
}
switch len(iregArgs) {
case 0, 1, 2, 3:
{
//Fast-Path: when arguments count are less than four, just exchange the registers
for i := 0; i < len(iregArgs); i++ {
p.MOVQ(iregOrderGo[i], iregOrderC[i])
}
}
case 4, 5, 6:
{
// need to spill 3th ~ regArgs registers before exchange
for i := 3; i < len(iregArgs); i++ {
arg := iregArgs[i]
// pointer args have already been spilled
if !arg.IsPointer {
p.MOVQ(iregOrderGo[i], Ptr(RSP, int32(self.Prev()+arg.Mem)))
}
}
p.MOVQ(iregOrderGo[0], iregOrderC[0])
p.MOVQ(iregOrderGo[1], iregOrderC[1])
p.MOVQ(iregOrderGo[2], iregOrderC[2])
for i := 3; i < len(iregArgs); i++ {
arg := iregArgs[i]
p.MOVQ(Ptr(RSP, int32(self.Prev()+arg.Mem)), iregOrderC[i])
}
}
default:
panic("too many arguments, only support at most 6 integer register arguments now")
}
}
func (self *Frame) emitStackCheck(p *Program, to *Label, maxStack uintptr) {
p.LEAQ(Ptr(RSP, int32(-(self.Size()+uint32(maxStack)))), R12)
p.CMPQ(Ptr(R14, _G_stackguard0), R12)
p.JBE(to)
}
func (self *Frame) StackCheckTextSize() uint32 {
p := DefaultArch.CreateProgram()
p.LEAQ(Ptr(RSP, int32(-(self.Size()))), R12)
p.CMPQ(Ptr(R14, _G_stackguard0), R12)
to := CreateLabel("")
p.Link(to)
p.JBE(to)
return uint32(len(p.Assemble(0)))
}
func (self *Frame) emitExchangeRets(p *Program) {
if len(self.desc.Rets) > 1 {
panic("too many results, only support one result now")
}
// store result
if len(self.desc.Rets) == 1 && !self.desc.Rets[0].InRegister {
if self.desc.Rets[0].IsFloat == floatKind64 {
p.MOVSD(xregOrderC[0], self.retv(0))
} else if self.desc.Rets[0].IsFloat == floatKind32 {
p.MOVSS(xregOrderC[0], self.retv(0))
} else {
p.MOVQ(RAX, self.retv(0))
}
}
}
func (self *Frame) emitRestoreRegs(p *Program) {
// load reserved registers
for i, r := range ReservedRegs(self.ccall) {
switch r.(type) {
case Register64:
p.MOVQ(self.resv(i), r)
case XMMRegister:
p.MOVSD(self.resv(i), r)
default:
panic(fmt.Sprintf("unsupported register type %t to reserve", r))
}
}
// zero xmm15 for go abi
p.XORPS(zeroRegGo, zeroRegGo)
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/internal/abi/stubs.go | vendor/github.com/bytedance/sonic/loader/internal/abi/stubs.go | /**
* Copyright 2023 ByteDance Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package abi
import (
_ `unsafe`
`github.com/bytedance/sonic/loader/internal/rt`
)
const (
_G_stackguard0 = 0x10
)
var (
F_morestack_noctxt = uintptr(rt.FuncAddr(morestack_noctxt))
)
//go:linkname morestack_noctxt runtime.morestack_noctxt
func morestack_noctxt()
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/internal/abi/abi_legacy_amd64.go | vendor/github.com/bytedance/sonic/loader/internal/abi/abi_legacy_amd64.go | //go:build !go1.17
// +build !go1.17
/*
* Copyright 2022 ByteDance Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package abi
import (
"fmt"
"reflect"
"runtime"
)
func ReservedRegs(callc bool) []Register {
return nil
}
func salloc(p []Parameter, sp uint32, vt reflect.Type) (uint32, []Parameter) {
switch vt.Kind() {
case reflect.Bool:
return sp + 8, append(p, mkStack(reflect.TypeOf(false), sp))
case reflect.Int:
return sp + 8, append(p, mkStack(intType, sp))
case reflect.Int8:
return sp + 8, append(p, mkStack(reflect.TypeOf(int8(0)), sp))
case reflect.Int16:
return sp + 8, append(p, mkStack(reflect.TypeOf(int16(0)), sp))
case reflect.Int32:
return sp + 8, append(p, mkStack(reflect.TypeOf(int32(0)), sp))
case reflect.Int64:
return sp + 8, append(p, mkStack(reflect.TypeOf(int64(0)), sp))
case reflect.Uint:
return sp + 8, append(p, mkStack(reflect.TypeOf(uint(0)), sp))
case reflect.Uint8:
return sp + 8, append(p, mkStack(reflect.TypeOf(uint8(0)), sp))
case reflect.Uint16:
return sp + 8, append(p, mkStack(reflect.TypeOf(uint16(0)), sp))
case reflect.Uint32:
return sp + 8, append(p, mkStack(reflect.TypeOf(uint32(0)), sp))
case reflect.Uint64:
return sp + 8, append(p, mkStack(reflect.TypeOf(uint64(0)), sp))
case reflect.Uintptr:
return sp + 8, append(p, mkStack(reflect.TypeOf(uintptr(0)), sp))
case reflect.Float32:
return sp + 8, append(p, mkStack(reflect.TypeOf(float32(0)), sp))
case reflect.Float64:
return sp + 8, append(p, mkStack(reflect.TypeOf(float64(0)), sp))
case reflect.Complex64:
panic("abi: go116: not implemented: complex64")
case reflect.Complex128:
panic("abi: go116: not implemented: complex128")
case reflect.Array:
panic("abi: go116: not implemented: arrays")
case reflect.Chan:
return sp + 8, append(p, mkStack(reflect.TypeOf((chan int)(nil)), sp))
case reflect.Func:
return sp + 8, append(p, mkStack(reflect.TypeOf((func())(nil)), sp))
case reflect.Map:
return sp + 8, append(p, mkStack(reflect.TypeOf((map[int]int)(nil)), sp))
case reflect.Ptr:
return sp + 8, append(p, mkStack(reflect.TypeOf((*int)(nil)), sp))
case reflect.UnsafePointer:
return sp + 8, append(p, mkStack(ptrType, sp))
case reflect.Interface:
return sp + 16, append(p, mkStack(ptrType, sp), mkStack(ptrType, sp+8))
case reflect.Slice:
return sp + 24, append(p, mkStack(ptrType, sp), mkStack(intType, sp+8), mkStack(intType, sp+16))
case reflect.String:
return sp + 16, append(p, mkStack(ptrType, sp), mkStack(intType, sp+8))
case reflect.Struct:
panic("abi: go116: not implemented: structs")
default:
panic("abi: invalid value type")
}
}
func NewFunctionLayout(ft reflect.Type) FunctionLayout {
var sp uint32
var fn FunctionLayout
/* assign every arguments */
for i := 0; i < ft.NumIn(); i++ {
sp, fn.Args = salloc(fn.Args, sp, ft.In(i))
}
/* assign every return value */
for i := 0; i < ft.NumOut(); i++ {
sp, fn.Rets = salloc(fn.Rets, sp, ft.Out(i))
}
/* update function ID and stack pointer */
fn.FP = sp
return fn
}
func (self *Frame) emitExchangeArgs(p *Program) {
iregArgs, xregArgs := 0, 0
for _, v := range self.desc.Args {
if v.IsFloat != notFloatKind {
xregArgs += 1
} else {
iregArgs += 1
}
}
if iregArgs > len(iregOrderC) {
panic("too many arguments, only support at most 6 integer arguments now")
}
if xregArgs > len(xregOrderC) {
panic("too many arguments, only support at most 8 float arguments now")
}
ic, xc := iregArgs, xregArgs
for i := 0; i < len(self.desc.Args); i++ {
arg := self.desc.Args[i]
if arg.IsFloat == floatKind64 {
p.MOVSD(self.argv(i), xregOrderC[xregArgs-xc])
xc -= 1
} else if arg.IsFloat == floatKind32 {
p.MOVSS(self.argv(i), xregOrderC[xregArgs-xc])
xc -= 1
} else {
p.MOVQ(self.argv(i), iregOrderC[iregArgs-ic])
ic -= 1
}
}
}
func (self *Frame) emitStackCheck(p *Program, to *Label, maxStack uintptr) {
// get the current goroutine
switch runtime.GOOS {
case "linux":
p.MOVQ(Abs(-8), R14).FS()
case "darwin":
p.MOVQ(Abs(0x30), R14).GS()
case "windows":
break // windows always stores G pointer at R14
default:
panic("unsupported operating system")
}
// check the stack guard
p.LEAQ(Ptr(RSP, -int32(self.Size()+uint32(maxStack))), RAX)
p.CMPQ(Ptr(R14, _G_stackguard0), RAX)
p.JBE(to)
}
func (self *Frame) StackCheckTextSize() uint32 {
p := DefaultArch.CreateProgram()
// get the current goroutine
switch runtime.GOOS {
case "linux":
p.MOVQ(Abs(-8), R14).FS()
case "darwin":
p.MOVQ(Abs(0x30), R14).GS()
case "windows":
break // windows always stores G pointer at R14
default:
panic("unsupported operating system")
}
// check the stack guard
p.LEAQ(Ptr(RSP, -int32(self.Size())), RAX)
p.CMPQ(Ptr(R14, _G_stackguard0), RAX)
l := CreateLabel("")
p.Link(l)
p.JBE(l)
return uint32(len(p.Assemble(0)))
}
func (self *Frame) emitExchangeRets(p *Program) {
if len(self.desc.Rets) > 1 {
panic("too many results, only support one result now")
}
// store result
if len(self.desc.Rets) == 1 {
if self.desc.Rets[0].IsFloat == floatKind64 {
p.MOVSD(xregOrderC[0], self.retv(0))
} else if self.desc.Rets[0].IsFloat == floatKind32 {
p.MOVSS(xregOrderC[0], self.retv(0))
} else {
p.MOVQ(RAX, self.retv(0))
}
}
}
func (self *Frame) emitRestoreRegs(p *Program) {
// load reserved registers
for i, r := range ReservedRegs(self.ccall) {
switch r.(type) {
case Register64:
p.MOVQ(self.resv(i), r)
case XMMRegister:
p.MOVSD(self.resv(i), r)
default:
panic(fmt.Sprintf("unsupported register type %t to reserve", r))
}
}
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/internal/rt/fastvalue.go | vendor/github.com/bytedance/sonic/loader/internal/rt/fastvalue.go | /*
* 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 rt
import (
`reflect`
`unsafe`
)
var (
reflectRtypeItab = findReflectRtypeItab()
)
// GoType.KindFlags const
const (
F_direct = 1 << 5
F_kind_mask = (1 << 5) - 1
)
// GoType.Flags const
const (
tflagUncommon uint8 = 1 << 0
tflagExtraStar uint8 = 1 << 1
tflagNamed uint8 = 1 << 2
tflagRegularMemory uint8 = 1 << 3
)
type GoType struct {
Size uintptr
PtrData uintptr
Hash uint32
Flags uint8
Align uint8
FieldAlign uint8
KindFlags uint8
Traits unsafe.Pointer
GCData *byte
Str int32
PtrToSelf int32
}
func (self *GoType) IsNamed() bool {
return (self.Flags & tflagNamed) != 0
}
func (self *GoType) Kind() reflect.Kind {
return reflect.Kind(self.KindFlags & F_kind_mask)
}
func (self *GoType) Pack() (t reflect.Type) {
(*GoIface)(unsafe.Pointer(&t)).Itab = reflectRtypeItab
(*GoIface)(unsafe.Pointer(&t)).Value = unsafe.Pointer(self)
return
}
func (self *GoType) String() string {
return self.Pack().String()
}
func (self *GoType) Indirect() bool {
return self.KindFlags & F_direct == 0
}
type GoItab struct {
it unsafe.Pointer
Vt *GoType
hv uint32
_ [4]byte
fn [1]uintptr
}
type GoIface struct {
Itab *GoItab
Value unsafe.Pointer
}
type GoEface struct {
Type *GoType
Value unsafe.Pointer
}
func (self GoEface) Pack() (v interface{}) {
*(*GoEface)(unsafe.Pointer(&v)) = self
return
}
type GoPtrType struct {
GoType
Elem *GoType
}
type GoMapType struct {
GoType
Key *GoType
Elem *GoType
Bucket *GoType
Hasher func(unsafe.Pointer, uintptr) uintptr
KeySize uint8
ElemSize uint8
BucketSize uint16
Flags uint32
}
func (self *GoMapType) IndirectElem() bool {
return self.Flags & 2 != 0
}
type GoStructType struct {
GoType
Pkg *byte
Fields []GoStructField
}
type GoStructField struct {
Name *byte
Type *GoType
OffEmbed uintptr
}
type GoInterfaceType struct {
GoType
PkgPath *byte
Methods []GoInterfaceMethod
}
type GoInterfaceMethod struct {
Name int32
Type int32
}
type GoSlice struct {
Ptr unsafe.Pointer
Len int
Cap int
}
type GoString struct {
Ptr unsafe.Pointer
Len int
}
func PtrElem(t *GoType) *GoType {
return (*GoPtrType)(unsafe.Pointer(t)).Elem
}
func MapType(t *GoType) *GoMapType {
return (*GoMapType)(unsafe.Pointer(t))
}
func IfaceType(t *GoType) *GoInterfaceType {
return (*GoInterfaceType)(unsafe.Pointer(t))
}
func UnpackType(t reflect.Type) *GoType {
return (*GoType)((*GoIface)(unsafe.Pointer(&t)).Value)
}
func UnpackEface(v interface{}) GoEface {
return *(*GoEface)(unsafe.Pointer(&v))
}
func UnpackIface(v interface{}) GoIface {
return *(*GoIface)(unsafe.Pointer(&v))
}
func findReflectRtypeItab() *GoItab {
v := reflect.TypeOf(struct{}{})
return (*GoIface)(unsafe.Pointer(&v)).Itab
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/internal/rt/stackmap.go | vendor/github.com/bytedance/sonic/loader/internal/rt/stackmap.go | /**
* Copyright 2023 ByteDance Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package rt
import (
`fmt`
`strings`
`unsafe`
)
type Bitmap struct {
N int
B []byte
}
func (self *Bitmap) grow() {
if self.N >= len(self.B) * 8 {
self.B = append(self.B, 0)
}
}
func (self *Bitmap) mark(i int, bv int) {
if bv != 0 {
self.B[i / 8] |= 1 << (i % 8)
} else {
self.B[i / 8] &^= 1 << (i % 8)
}
}
func (self *Bitmap) Set(i int, bv int) {
if i >= self.N {
panic("bitmap: invalid bit position")
} else {
self.mark(i, bv)
}
}
func (self *Bitmap) Append(bv int) {
self.grow()
self.mark(self.N, bv)
self.N++
}
func (self *Bitmap) AppendMany(n int, bv int) {
for i := 0; i < n; i++ {
self.Append(bv)
}
}
func (b *Bitmap) String() string {
var buf strings.Builder
for _, byteVal := range b.B {
fmt.Fprintf(&buf, "%08b ", byteVal)
}
return fmt.Sprintf("Bits: %s(total %d bits, %d bytes)", buf.String(), b.N, len(b.B))
}
type BitVec struct {
N uintptr
B unsafe.Pointer
}
func (self BitVec) Bit(i uintptr) byte {
return (*(*byte)(unsafe.Pointer(uintptr(self.B) + i / 8)) >> (i % 8)) & 1
}
func (self BitVec) String() string {
var i uintptr
var v []string
/* add each bit */
for i = 0; i < self.N; i++ {
v = append(v, fmt.Sprintf("%d", self.Bit(i)))
}
/* join them together */
return fmt.Sprintf(
"BitVec { %s }",
strings.Join(v, ", "),
)
}
/*
reference Golang 1.22.0 code:
```
args := bitvec.New(int32(maxArgs / int64(types.PtrSize)))
aoff := objw.Uint32(&argsSymTmp, 0, uint32(len(lv.stackMaps))) // number of bitmaps
aoff = objw.Uint32(&argsSymTmp, aoff, uint32(args.N)) // number of bits in each bitmap
locals := bitvec.New(int32(maxLocals / int64(types.PtrSize)))
loff := objw.Uint32(&liveSymTmp, 0, uint32(len(lv.stackMaps))) // number of bitmaps
loff = objw.Uint32(&liveSymTmp, loff, uint32(locals.N)) // number of bits in each bitmap
for _, live := range lv.stackMaps {
args.Clear()
locals.Clear()
lv.pointerMap(live, lv.vars, args, locals)
aoff = objw.BitVec(&argsSymTmp, aoff, args)
loff = objw.BitVec(&liveSymTmp, loff, locals)
}
```
*/
type StackMap struct {
// number of bitmaps
N int32
// number of bits of each bitmap
L int32
// bitmap1, bitmap2, ... bitmapN
B [1]byte
}
func (self *StackMap) Get(i int) BitVec {
return BitVec {
N: uintptr(self.L),
B: unsafe.Pointer(uintptr(unsafe.Pointer(&self.B)) + uintptr(i * self.BitmapBytes())),
}
}
func (self *StackMap) String() string {
sb := strings.Builder{}
sb.WriteString("StackMap {")
/* dump every stack map */
for i := 0; i < int(self.N); i++ {
sb.WriteRune('\n')
sb.WriteString(" " + self.Get(i).String())
}
/* close the stackmap */
sb.WriteString("\n}")
return sb.String()
}
func (self *StackMap) BitmapLen() int {
return int(self.L)
}
func (self *StackMap) BitmapBytes() int {
return int(self.L + 7) >> 3
}
func (self *StackMap) BitmapNums() int {
return int(self.N)
}
func (self *StackMap) StackMapHeaderSize() int {
return int(unsafe.Sizeof(self.L)) + int(unsafe.Sizeof(self.N))
}
func (self *StackMap) MarshalBinary() ([]byte, error) {
size := self.BinaryLen()
return BytesFrom(unsafe.Pointer(self), size, size), nil
}
func (self *StackMap) BinaryLen() int {
return self.StackMapHeaderSize() + self.BitmapBytes() * self.BitmapNums()
}
var (
byteType = UnpackEface(byte(0)).Type
)
const (
_StackMapSize = unsafe.Sizeof(StackMap{})
)
//go:linkname mallocgc runtime.mallocgc
//goland:noinspection GoUnusedParameter
func mallocgc(nb uintptr, vt *GoType, zero bool) unsafe.Pointer
type StackMapBuilder struct {
b Bitmap
}
//go:nocheckptr
func (self *StackMapBuilder) Build() (p *StackMap) {
nb := len(self.b.B)
allocatedSize := _StackMapSize + uintptr(nb) - 1
bm := mallocgc(allocatedSize, byteType, false)
/* initialize as 1 bitmap of N bits */
p = (*StackMap)(bm)
p.N, p.L = 1, int32(self.b.N)
copy(BytesFrom(unsafe.Pointer(&p.B), nb, nb), self.b.B)
/* assert length */
if allocatedSize < uintptr(p.BinaryLen()) {
panic(fmt.Sprintf("stackmap allocation too small: allocated %d, required %d", allocatedSize, p.BinaryLen()))
}
return
}
func (self *StackMapBuilder) AddField(ptr bool) {
if ptr {
self.b.Append(1)
} else {
self.b.Append(0)
}
}
func (self *StackMapBuilder) AddFields(n int, ptr bool) {
if ptr {
self.b.AppendMany(n, 1)
} else {
self.b.AppendMany(n, 0)
}
} | go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/loader/internal/rt/fastmem.go | vendor/github.com/bytedance/sonic/loader/internal/rt/fastmem.go | /*
* 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 rt
import (
`unsafe`
`reflect`
)
//go:nosplit
func Mem2Str(v []byte) (s string) {
(*GoString)(unsafe.Pointer(&s)).Len = (*GoSlice)(unsafe.Pointer(&v)).Len
(*GoString)(unsafe.Pointer(&s)).Ptr = (*GoSlice)(unsafe.Pointer(&v)).Ptr
return
}
//go:nosplit
func Str2Mem(s string) (v []byte) {
(*GoSlice)(unsafe.Pointer(&v)).Cap = (*GoString)(unsafe.Pointer(&s)).Len
(*GoSlice)(unsafe.Pointer(&v)).Len = (*GoString)(unsafe.Pointer(&s)).Len
(*GoSlice)(unsafe.Pointer(&v)).Ptr = (*GoString)(unsafe.Pointer(&s)).Ptr
return
}
func BytesFrom(p unsafe.Pointer, n int, c int) (r []byte) {
(*GoSlice)(unsafe.Pointer(&r)).Ptr = p
(*GoSlice)(unsafe.Pointer(&r)).Len = n
(*GoSlice)(unsafe.Pointer(&r)).Cap = c
return
}
func FuncAddr(f interface{}) unsafe.Pointer {
if vv := UnpackEface(f); vv.Type.Kind() != reflect.Func {
panic("f is not a function")
} else {
return *(*unsafe.Pointer)(vv.Value)
}
}
//go:nocheckptr
func IndexChar(src string, index int) unsafe.Pointer {
return unsafe.Pointer(uintptr((*GoString)(unsafe.Pointer(&src)).Ptr) + uintptr(index))
}
//go:nocheckptr
func IndexByte(ptr []byte, index int) unsafe.Pointer {
return unsafe.Pointer(uintptr((*GoSlice)(unsafe.Pointer(&ptr)).Ptr) + uintptr(index))
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/option/option.go | vendor/github.com/bytedance/sonic/option/option.go | /*
* 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 option
var (
// DefaultDecoderBufferSize is the initial buffer size of StreamDecoder
DefaultDecoderBufferSize uint = 4 * 1024
// DefaultEncoderBufferSize is the initial buffer size of Encoder
DefaultEncoderBufferSize uint = 4 * 1024
// DefaultAstBufferSize is the initial buffer size of ast.Node.MarshalJSON()
DefaultAstBufferSize uint = 4 * 1024
// LimitBufferSize indicates the max pool buffer size, in case of OOM.
// See issue https://github.com/bytedance/sonic/issues/614
LimitBufferSize uint = 1024 * 1024
)
// CompileOptions includes all options for encoder or decoder compiler.
type CompileOptions struct {
// the maximum depth for compilation inline
MaxInlineDepth int
// the loop times for recursively pretouch
RecursiveDepth int
}
var (
// Default value(3) means the compiler only inline 3 layers of nested struct.
// when the depth exceeds, the compiler will recurse
// and compile subsequent structs when they are decoded
DefaultMaxInlineDepth = 3
// Default value(1) means `Pretouch()` will be recursively executed once,
// if any nested struct is left (depth exceeds MaxInlineDepth)
DefaultRecursiveDepth = 1
)
// DefaultCompileOptions set default compile options.
func DefaultCompileOptions() CompileOptions {
return CompileOptions{
RecursiveDepth: DefaultRecursiveDepth,
MaxInlineDepth: DefaultMaxInlineDepth,
}
}
// CompileOption is a function used to change DefaultCompileOptions.
type CompileOption func(o *CompileOptions)
// WithCompileRecursiveDepth sets the loop times of recursive pretouch
// in both decoder and encoder,
// for both concrete type and its pointer type.
//
// For deep nested struct (depth exceeds MaxInlineDepth),
// try to set more loops to completely compile,
// thus reduce JIT instability in the first hit.
func WithCompileRecursiveDepth(loop int) CompileOption {
return func(o *CompileOptions) {
if loop < 0 {
panic("loop must be >= 0")
}
o.RecursiveDepth = loop
}
}
// WithCompileMaxInlineDepth sets the max depth of inline compile
// in decoder and encoder.
//
// For large nested struct, try to set smaller depth to reduce compiling time.
func WithCompileMaxInlineDepth(depth int) CompileOption {
return func(o *CompileOptions) {
if depth <= 0 {
panic("depth must be > 0")
}
o.MaxInlineDepth = depth
}
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/encoder/encoder_compat.go | vendor/github.com/bytedance/sonic/encoder/encoder_compat.go | // +build !amd64,!arm64 go1.25 !go1.17 arm64,!go1.20
/*
* Copyright 2023 ByteDance Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package encoder
import (
`io`
`bytes`
`encoding/json`
`reflect`
`github.com/bytedance/sonic/option`
`github.com/bytedance/sonic/internal/compat`
)
func init() {
compat.Warn("sonic/encoder")
}
// EnableFallback indicates if encoder use fallback
const EnableFallback = true
// Options is a set of encoding options.
type Options uint64
const (
bitSortMapKeys = iota
bitEscapeHTML
bitCompactMarshaler
bitNoQuoteTextMarshaler
bitNoNullSliceOrMap
bitValidateString
bitNoValidateJSONMarshaler
bitNoEncoderNewline
// used for recursive compile
bitPointerValue = 63
)
const (
// SortMapKeys indicates that the keys of a map needs to be sorted
// before serializing into JSON.
// WARNING: This hurts performance A LOT, USE WITH CARE.
SortMapKeys Options = 1 << bitSortMapKeys
// EscapeHTML indicates encoder to escape all HTML characters
// after serializing into JSON (see https://pkg.go.dev/encoding/json#HTMLEscape).
// WARNING: This hurts performance A LOT, USE WITH CARE.
EscapeHTML Options = 1 << bitEscapeHTML
// CompactMarshaler indicates that the output JSON from json.Marshaler
// is always compact and needs no validation
CompactMarshaler Options = 1 << bitCompactMarshaler
// NoQuoteTextMarshaler indicates that the output text from encoding.TextMarshaler
// is always escaped string and needs no quoting
NoQuoteTextMarshaler Options = 1 << bitNoQuoteTextMarshaler
// NoNullSliceOrMap indicates all empty Array or Object are encoded as '[]' or '{}',
// instead of 'null'
NoNullSliceOrMap Options = 1 << bitNoNullSliceOrMap
// ValidateString indicates that encoder should validate the input string
// before encoding it into JSON.
ValidateString Options = 1 << bitValidateString
// NoValidateJSONMarshaler indicates that the encoder should not validate the output string
// after encoding the JSONMarshaler to JSON.
NoValidateJSONMarshaler Options = 1 << bitNoValidateJSONMarshaler
// NoEncoderNewline indicates that the encoder should not add a newline after every message
NoEncoderNewline Options = 1 << bitNoEncoderNewline
// CompatibleWithStd is used to be compatible with std encoder.
CompatibleWithStd Options = SortMapKeys | EscapeHTML | CompactMarshaler
)
// Encoder represents a specific set of encoder configurations.
type Encoder struct {
Opts Options
prefix string
indent string
}
// Encode returns the JSON encoding of v.
func (self *Encoder) Encode(v interface{}) ([]byte, error) {
if self.indent != "" || self.prefix != "" {
return EncodeIndented(v, self.prefix, self.indent, self.Opts)
}
return Encode(v, self.Opts)
}
// SortKeys enables the SortMapKeys option.
func (self *Encoder) SortKeys() *Encoder {
self.Opts |= SortMapKeys
return self
}
// SetEscapeHTML specifies if option EscapeHTML opens
func (self *Encoder) SetEscapeHTML(f bool) {
if f {
self.Opts |= EscapeHTML
} else {
self.Opts &= ^EscapeHTML
}
}
// SetValidateString specifies if option ValidateString opens
func (self *Encoder) SetValidateString(f bool) {
if f {
self.Opts |= ValidateString
} else {
self.Opts &= ^ValidateString
}
}
// SetNoValidateJSONMarshaler specifies if option NoValidateJSONMarshaler opens
func (self *Encoder) SetNoValidateJSONMarshaler(f bool) {
if f {
self.Opts |= NoValidateJSONMarshaler
} else {
self.Opts &= ^NoValidateJSONMarshaler
}
}
// SetNoEncoderNewline specifies if option NoEncoderNewline opens
func (self *Encoder) SetNoEncoderNewline(f bool) {
if f {
self.Opts |= NoEncoderNewline
} else {
self.Opts &= ^NoEncoderNewline
}
}
// SetCompactMarshaler specifies if option CompactMarshaler opens
func (self *Encoder) SetCompactMarshaler(f bool) {
if f {
self.Opts |= CompactMarshaler
} else {
self.Opts &= ^CompactMarshaler
}
}
// SetNoQuoteTextMarshaler specifies if option NoQuoteTextMarshaler opens
func (self *Encoder) SetNoQuoteTextMarshaler(f bool) {
if f {
self.Opts |= NoQuoteTextMarshaler
} else {
self.Opts &= ^NoQuoteTextMarshaler
}
}
// SetIndent instructs the encoder to format each subsequent encoded
// value as if indented by the package-level function EncodeIndent().
// Calling SetIndent("", "") disables indentation.
func (enc *Encoder) SetIndent(prefix, indent string) {
enc.prefix = prefix
enc.indent = indent
}
// Quote returns the JSON-quoted version of s.
func Quote(s string) string {
/* check for empty string */
if s == "" {
return `""`
}
out, _ := json.Marshal(s)
return string(out)
}
// Encode returns the JSON encoding of val, encoded with opts.
func Encode(val interface{}, opts Options) ([]byte, error) {
return json.Marshal(val)
}
// EncodeInto is like Encode but uses a user-supplied buffer instead of allocating
// a new one.
func EncodeInto(buf *[]byte, val interface{}, opts Options) error {
if buf == nil {
panic("user-supplied buffer buf is nil")
}
w := bytes.NewBuffer(*buf)
enc := json.NewEncoder(w)
enc.SetEscapeHTML((opts & EscapeHTML) != 0)
err := enc.Encode(val)
*buf = w.Bytes()
l := len(*buf)
if l > 0 && (opts & NoEncoderNewline != 0) && (*buf)[l-1] == '\n' {
*buf = (*buf)[:l-1]
}
return err
}
// HTMLEscape appends to dst the JSON-encoded src with <, >, &, U+2028 and U+2029
// characters inside string literals changed to \u003c, \u003e, \u0026, \u2028, \u2029
// so that the JSON will be safe to embed inside HTML <script> tags.
// For historical reasons, web browsers don't honor standard HTML
// escaping within <script> tags, so an alternative JSON encoding must
// be used.
func HTMLEscape(dst []byte, src []byte) []byte {
d := bytes.NewBuffer(dst)
json.HTMLEscape(d, src)
return d.Bytes()
}
// EncodeIndented is like Encode but applies Indent to format the output.
// Each JSON element in the output will begin on a new line beginning with prefix
// followed by one or more copies of indent according to the indentation nesting.
func EncodeIndented(val interface{}, prefix string, indent string, opts Options) ([]byte, error) {
w := bytes.NewBuffer([]byte{})
enc := json.NewEncoder(w)
enc.SetEscapeHTML((opts & EscapeHTML) != 0)
enc.SetIndent(prefix, indent)
err := enc.Encode(val)
out := w.Bytes()
return out, err
}
// Pretouch compiles vt ahead-of-time to avoid JIT compilation on-the-fly, in
// order to reduce the first-hit latency.
//
// Opts are the compile options, for example, "option.WithCompileRecursiveDepth" is
// a compile option to set the depth of recursive compile for the nested struct type.
func Pretouch(vt reflect.Type, opts ...option.CompileOption) error {
return nil
}
// Valid validates json and returns first non-blank character position,
// if it is only one valid json value.
// Otherwise returns invalid character position using start.
//
// Note: it does not check for the invalid UTF-8 characters.
func Valid(data []byte) (ok bool, start int) {
return json.Valid(data), 0
}
// StreamEncoder uses io.Writer as
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 json.NewEncoder(w)
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/encoder/encoder_native.go | vendor/github.com/bytedance/sonic/encoder/encoder_native.go | // +build amd64,go1.17,!go1.25 arm64,go1.20,!go1.25
/*
* Copyright 2023 ByteDance Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package encoder
import (
`github.com/bytedance/sonic/internal/encoder`
)
// EnableFallback indicates if encoder use fallback
const EnableFallback = false
// Encoder represents a specific set of encoder configurations.
type Encoder = encoder.Encoder
// StreamEncoder uses io.Writer as input.
type StreamEncoder = encoder.StreamEncoder
// Options is a set of encoding options.
type Options = encoder.Options
const (
// SortMapKeys indicates that the keys of a map needs to be sorted
// before serializing into JSON.
// WARNING: This hurts performance A LOT, USE WITH CARE.
SortMapKeys Options = encoder.SortMapKeys
// EscapeHTML indicates encoder to escape all HTML characters
// after serializing into JSON (see https://pkg.go.dev/encoding/json#HTMLEscape).
// WARNING: This hurts performance A LOT, USE WITH CARE.
EscapeHTML Options = encoder.EscapeHTML
// CompactMarshaler indicates that the output JSON from json.Marshaler
// is always compact and needs no validation
CompactMarshaler Options = encoder.CompactMarshaler
// NoQuoteTextMarshaler indicates that the output text from encoding.TextMarshaler
// is always escaped string and needs no quoting
NoQuoteTextMarshaler Options = encoder.NoQuoteTextMarshaler
// NoNullSliceOrMap indicates all empty Array or Object are encoded as '[]' or '{}',
// instead of 'null'
NoNullSliceOrMap Options = encoder.NoNullSliceOrMap
// ValidateString indicates that encoder should validate the input string
// before encoding it into JSON.
ValidateString Options = encoder.ValidateString
// NoValidateJSONMarshaler indicates that the encoder should not validate the output string
// after encoding the JSONMarshaler to JSON.
NoValidateJSONMarshaler Options = encoder.NoValidateJSONMarshaler
// NoEncoderNewline indicates that the encoder should not add a newline after every message
NoEncoderNewline Options = encoder.NoEncoderNewline
// CompatibleWithStd is used to be compatible with std encoder.
CompatibleWithStd Options = encoder.CompatibleWithStd
// Encode Infinity or Nan float into `null`, instead of returning an error.
EncodeNullForInfOrNan Options = encoder.EncodeNullForInfOrNan
)
var (
// Encode returns the JSON encoding of val, encoded with opts.
Encode = encoder.Encode
// EncodeInto is like Encode but uses a user-supplied buffer instead of allocating a new one.
EncodeIndented = encoder.EncodeIndented
// EncodeIndented is like Encode but applies Indent to format the output.
// Each JSON element in the output will begin on a new line beginning with prefix
// followed by one or more copies of indent according to the indentation nesting.
EncodeInto = encoder.EncodeInto
// HTMLEscape appends to dst the JSON-encoded src with <, >, &, U+2028 and U+2029
// characters inside string literals changed to \u003c, \u003e, \u0026, \u2028, \u2029
// so that the JSON will be safe to embed inside HTML <script> tags.
// For historical reasons, web browsers don't honor standard HTML
// escaping within <script> tags, so an alternative JSON encoding must
// be used.
HTMLEscape = encoder.HTMLEscape
// Pretouch compiles vt ahead-of-time to avoid JIT compilation on-the-fly, in
// order to reduce the first-hit latency.
//
// Opts are the compile options, for example, "option.WithCompileRecursiveDepth" is
// a compile option to set the depth of recursive compile for the nested struct type.
Pretouch = encoder.Pretouch
// Quote returns the JSON-quoted version of s.
Quote = encoder.Quote
// Valid validates json and returns first non-blank character position,
// if it is only one valid json value.
// Otherwise returns invalid character position using start.
//
// Note: it does not check for the invalid UTF-8 characters.
Valid = encoder.Valid
// NewStreamEncoder adapts to encoding/json.NewDecoder API.
//
// NewStreamEncoder returns a new encoder that write to w.
NewStreamEncoder = encoder.NewStreamEncoder
)
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/decoder/decoder_compat.go | vendor/github.com/bytedance/sonic/decoder/decoder_compat.go | //go:build (!amd64 && !arm64) || go1.25 || !go1.17 || (arm64 && !go1.20)
// +build !amd64,!arm64 go1.25 !go1.17 arm64,!go1.20
/*
* Copyright 2023 ByteDance Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package decoder
import (
"bytes"
"encoding/json"
"io"
"reflect"
"unsafe"
"github.com/bytedance/sonic/internal/decoder/consts"
"github.com/bytedance/sonic/internal/native/types"
"github.com/bytedance/sonic/option"
"github.com/bytedance/sonic/internal/compat"
)
func init() {
compat.Warn("sonic/decoder")
}
const (
_F_use_int64 = consts.F_use_int64
_F_disable_urc = consts.F_disable_unknown
_F_disable_unknown = consts.F_disable_unknown
_F_copy_string = consts.F_copy_string
_F_use_number = consts.F_use_number
_F_validate_string = consts.F_validate_string
_F_allow_control = consts.F_allow_control
_F_no_validate_json = consts.F_no_validate_json
_F_case_sensitive = consts.F_case_sensitive
)
type Options uint64
const (
OptionUseInt64 Options = 1 << _F_use_int64
OptionUseNumber Options = 1 << _F_use_number
OptionUseUnicodeErrors Options = 1 << _F_disable_urc
OptionDisableUnknown Options = 1 << _F_disable_unknown
OptionCopyString Options = 1 << _F_copy_string
OptionValidateString Options = 1 << _F_validate_string
OptionNoValidateJSON Options = 1 << _F_no_validate_json
OptionCaseSensitive Options = 1 << _F_case_sensitive
)
func (self *Decoder) SetOptions(opts Options) {
if (opts & OptionUseNumber != 0) && (opts & OptionUseInt64 != 0) {
panic("can't set OptionUseInt64 and OptionUseNumber both!")
}
self.f = uint64(opts)
}
// Decoder is the decoder context object
type Decoder struct {
i int
f uint64
s string
}
// NewDecoder creates a new decoder instance.
func NewDecoder(s string) *Decoder {
return &Decoder{s: s}
}
// Pos returns the current decoding position.
func (self *Decoder) Pos() int {
return self.i
}
func (self *Decoder) Reset(s string) {
self.s = s
self.i = 0
// self.f = 0
}
// NOTE: api fallback do nothing
func (self *Decoder) CheckTrailings() error {
pos := self.i
buf := self.s
/* skip all the trailing spaces */
if pos != len(buf) {
for pos < len(buf) && (types.SPACE_MASK & (1 << buf[pos])) != 0 {
pos++
}
}
/* then it must be at EOF */
if pos == len(buf) {
return nil
}
/* junk after JSON value */
return nil
}
// Decode parses the JSON-encoded data from current position and stores the result
// in the value pointed to by val.
func (self *Decoder) Decode(val interface{}) error {
r := bytes.NewBufferString(self.s)
dec := json.NewDecoder(r)
if (self.f & uint64(OptionUseNumber)) != 0 {
dec.UseNumber()
}
if (self.f & uint64(OptionDisableUnknown)) != 0 {
dec.DisallowUnknownFields()
}
return dec.Decode(val)
}
// UseInt64 indicates the Decoder to unmarshal an integer into an interface{} as an
// int64 instead of as a float64.
func (self *Decoder) UseInt64() {
self.f |= 1 << _F_use_int64
self.f &^= 1 << _F_use_number
}
// UseNumber indicates the Decoder to unmarshal a number into an interface{} as a
// json.Number instead of as a float64.
func (self *Decoder) UseNumber() {
self.f &^= 1 << _F_use_int64
self.f |= 1 << _F_use_number
}
// UseUnicodeErrors indicates the Decoder to return an error when encounter invalid
// UTF-8 escape sequences.
func (self *Decoder) UseUnicodeErrors() {
self.f |= 1 << _F_disable_urc
}
// DisallowUnknownFields indicates the Decoder to return an error when the destination
// is a struct and the input contains object keys which do not match any
// non-ignored, exported fields in the destination.
func (self *Decoder) DisallowUnknownFields() {
self.f |= 1 << _F_disable_unknown
}
// CopyString indicates the Decoder to decode string values by copying instead of referring.
func (self *Decoder) CopyString() {
self.f |= 1 << _F_copy_string
}
// ValidateString causes the Decoder to validate string values when decoding string value
// in JSON. Validation is that, returning error when unescaped control chars(0x00-0x1f) or
// invalid UTF-8 chars in the string value of JSON.
func (self *Decoder) ValidateString() {
self.f |= 1 << _F_validate_string
}
// Pretouch compiles vt ahead-of-time to avoid JIT compilation on-the-fly, in
// order to reduce the first-hit latency.
//
// Opts are the compile options, for example, "option.WithCompileRecursiveDepth" is
// a compile option to set the depth of recursive compile for the nested struct type.
func Pretouch(vt reflect.Type, opts ...option.CompileOption) error {
return nil
}
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 json.NewDecoder(r)
}
// 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 mismatching between json and object
type MismatchTypeError json.UnmarshalTypeError
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/decoder/decoder_native.go | vendor/github.com/bytedance/sonic/decoder/decoder_native.go | //go:build (amd64 && go1.17 && !go1.25) || (arm64 && go1.20 && !go1.25)
// +build amd64,go1.17,!go1.25 arm64,go1.20,!go1.25
/*
* Copyright 2023 ByteDance Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package decoder
import (
`github.com/bytedance/sonic/internal/decoder/api`
)
// Decoder is the decoder context object
type Decoder = api.Decoder
// SyntaxError represents json syntax error
type SyntaxError = api.SyntaxError
// MismatchTypeError represents mismatching between json and object
type MismatchTypeError = api.MismatchTypeError
// Options for decode.
type Options = api.Options
const (
OptionUseInt64 Options = api.OptionUseInt64
OptionUseNumber Options = api.OptionUseNumber
OptionUseUnicodeErrors Options = api.OptionUseUnicodeErrors
OptionDisableUnknown Options = api.OptionDisableUnknown
OptionCopyString Options = api.OptionCopyString
OptionValidateString Options = api.OptionValidateString
OptionNoValidateJSON Options = api.OptionNoValidateJSON
OptionCaseSensitive Options = api.OptionCaseSensitive
)
// StreamDecoder is the decoder context object for streaming input.
type StreamDecoder = api.StreamDecoder
var (
// NewDecoder creates a new decoder instance.
NewDecoder = api.NewDecoder
// NewStreamDecoder adapts to encoding/json.NewDecoder API.
//
// NewStreamDecoder returns a new decoder that reads from r.
NewStreamDecoder = api.NewStreamDecoder
// Pretouch compiles vt ahead-of-time to avoid JIT compilation on-the-fly, in
// order to reduce the first-hit latency.
//
// Opts are the compile options, for example, "option.WithCompileRecursiveDepth" is
// a compile option to set the depth of recursive compile for the nested struct type.
Pretouch = api.Pretouch
// Skip skips only one json value, and returns first non-blank character position and its ending position if it is valid.
// Otherwise, returns negative error code using start and invalid character position using end
Skip = api.Skip
)
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/compat/warn.go | vendor/github.com/bytedance/sonic/internal/compat/warn.go | // +build !amd64,!arm64 go1.25 !go1.17 arm64,!go1.20
package compat
import (
"fmt"
"os"
)
func Warn(prefix string) {
fmt.Fprintf(os.Stderr, "WARNING: %s only supports (go1.17~1.24 && amd64 CPU) or (go1.20~1.24 && arm64 CPU), but your environment is not suitable and will fallback to encoding/json\n", prefix)
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/dispatch_arm64.go | vendor/github.com/bytedance/sonic/internal/native/dispatch_arm64.go | /*
* 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 native
import (
`unsafe`
neon `github.com/bytedance/sonic/internal/native/neon`
`github.com/bytedance/sonic/internal/native/types`
)
const (
MaxFrameSize uintptr = 200
BufPaddingSize int = 64
)
var (
S_f64toa uintptr
S_f32toa uintptr
S_i64toa uintptr
S_u64toa uintptr
S_lspace uintptr
)
var (
S_quote uintptr
S_unquote uintptr
)
var (
S_value uintptr
S_vstring uintptr
S_vnumber uintptr
S_vsigned uintptr
S_vunsigned uintptr
)
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_parse_with_padding uintptr
S_lookup_small_key uintptr
)
//go:nosplit
//go:noescape
//go:linkname Quote github.com/bytedance/sonic/internal/native/neon.__quote
func Quote(s unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int, flags uint64) int
//go:nosplit
//go:noescape
//go:linkname Unquote github.com/bytedance/sonic/internal/native/neon.__unquote
func Unquote(s unsafe.Pointer, nb int, dp unsafe.Pointer, ep *int, flags uint64) int
//go:nosplit
//go:noescape
//go:linkname HTMLEscape github.com/bytedance/sonic/internal/native/neon.__html_escape
func HTMLEscape(s unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int) int
//go:nosplit
//go:noescape
//go:linkname Value github.com/bytedance/sonic/internal/native/neon.__value
func Value(s unsafe.Pointer, n int, p int, v *types.JsonState, flags uint64) int
//go:nosplit
//go:noescape
//go:linkname SkipOne github.com/bytedance/sonic/internal/native/neon.__skip_one
func SkipOne(s *string, p *int, m *types.StateMachine, flags uint64) int
//go:nosplit
//go:noescape
//go:linkname SkipOneFast github.com/bytedance/sonic/internal/native/neon.__skip_one_fast
func SkipOneFast(s *string, p *int) int
//go:nosplit
//go:noescape
//go:linkname GetByPath github.com/bytedance/sonic/internal/native/neon.__get_by_path
func GetByPath(s *string, p *int, path *[]interface{}, m *types.StateMachine) int
//go:nosplit
//go:noescape
//go:linkname ValidateOne github.com/bytedance/sonic/internal/native/neon.__validate_one
func ValidateOne(s *string, p *int, m *types.StateMachine, flags uint64) int
//go:nosplit
//go:noescape
//go:linkname I64toa github.com/bytedance/sonic/internal/native/neon.__i64toa
func I64toa(out *byte, val int64) (ret int)
//go:nosplit
//go:noescape
//go:linkname U64toa github.com/bytedance/sonic/internal/native/neon.__u64toa
func U64toa(out *byte, val uint64) (ret int)
//go:nosplit
//go:noescape
//go:linkname F64toa github.com/bytedance/sonic/internal/native/neon.__f64toa
func F64toa(out *byte, val float64) (ret int)
//go:nosplit
//go:noescape
//go:linkname F32toa github.com/bytedance/sonic/internal/native/neon.__f32toa
func F32toa(out *byte, val float32) (ret int)
//go:nosplit
//go:noescape
//go:linkname ValidateUTF8 github.com/bytedance/sonic/internal/native/neon.__validate_utf8
func ValidateUTF8(s *string, p *int, m *types.StateMachine) (ret int)
//go:nosplit
//go:noescape
//go:linkname ValidateUTF8Fast github.com/bytedance/sonic/internal/native/neon.__validate_utf8_fast
func ValidateUTF8Fast(s *string) (ret int)
//go:nosplit
//go:noescape
//go:linkname ParseWithPadding github.com/bytedance/sonic/internal/native/neon.__parse_with_padding
func ParseWithPadding(parser unsafe.Pointer) (ret int)
//go:nosplit
//go:noescape
//go:linkname LookupSmallKey github.com/bytedance/sonic/internal/native/neon.__lookup_small_key
func LookupSmallKey(key *string, table *[]byte, lowerOff int) (index int)
func useNeon() {
S_f64toa = neon.S_f64toa
S_f32toa = neon.S_f32toa
S_i64toa = neon.S_i64toa
S_u64toa = neon.S_u64toa
S_lspace = neon.S_lspace
S_quote = neon.S_quote
S_unquote = neon.S_unquote
S_value = neon.S_value
S_vstring = neon.S_vstring
S_vnumber = neon.S_vnumber
S_vsigned = neon.S_vsigned
S_vunsigned = neon.S_vunsigned
S_skip_one = neon.S_skip_one
S_skip_one_fast = neon.S_skip_one_fast
S_skip_array = neon.S_skip_array
S_skip_object = neon.S_skip_object
S_skip_number = neon.S_skip_number
S_get_by_path = neon.S_get_by_path
S_parse_with_padding = neon.S_parse_with_padding
S_lookup_small_key = neon.S_lookup_small_key
}
func init() {
useNeon()
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/dispatch_amd64.go | vendor/github.com/bytedance/sonic/internal/native/dispatch_amd64.go | /*
* 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 native
import (
`unsafe`
`github.com/bytedance/sonic/internal/cpu`
`github.com/bytedance/sonic/internal/native/avx2`
`github.com/bytedance/sonic/internal/native/sse`
`github.com/bytedance/sonic/internal/native/types`
`github.com/bytedance/sonic/internal/rt`
)
const MaxFrameSize uintptr = 400
var (
S_f64toa uintptr
S_f32toa uintptr
S_i64toa uintptr
S_u64toa uintptr
S_lspace uintptr
)
var (
S_quote uintptr
S_unquote uintptr
)
var (
S_value uintptr
S_vstring uintptr
S_vnumber uintptr
S_vsigned uintptr
S_vunsigned uintptr
)
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
)
var (
__Quote func(s unsafe.Pointer, nb int, dp unsafe.Pointer, dn unsafe.Pointer, flags uint64) int
__Unquote func(s unsafe.Pointer, nb int, dp unsafe.Pointer, ep unsafe.Pointer, flags uint64) int
__HTMLEscape func(s unsafe.Pointer, nb int, dp unsafe.Pointer, dn unsafe.Pointer) int
__Value func(s unsafe.Pointer, n int, p int, v unsafe.Pointer, flags uint64) int
__SkipOne func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer, flags uint64) int
__SkipOneFast func(s unsafe.Pointer, p unsafe.Pointer) int
__GetByPath func(s unsafe.Pointer, p unsafe.Pointer, path unsafe.Pointer, m unsafe.Pointer) int
__ValidateOne func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer, flags uint64) int
__I64toa func(out unsafe.Pointer, val int64) (ret int)
__U64toa func(out unsafe.Pointer, val uint64) (ret int)
__F64toa func(out unsafe.Pointer, val float64) (ret int)
__F32toa func(out unsafe.Pointer, val float32) (ret int)
__ValidateUTF8 func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer) (ret int)
__ValidateUTF8Fast func(s unsafe.Pointer) (ret int)
__ParseWithPadding func(parser unsafe.Pointer) (ret int)
__LookupSmallKey func(key unsafe.Pointer, table unsafe.Pointer, lowerOff int) (index int)
)
//go:nosplit
func Quote(s unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int, flags uint64) int {
return __Quote(rt.NoEscape(unsafe.Pointer(s)), nb, rt.NoEscape(unsafe.Pointer(dp)), rt.NoEscape(unsafe.Pointer(dn)), flags)
}
//go:nosplit
func Unquote(s unsafe.Pointer, nb int, dp unsafe.Pointer, ep *int, flags uint64) int {
return __Unquote(rt.NoEscape(unsafe.Pointer(s)), nb, rt.NoEscape(unsafe.Pointer(dp)), rt.NoEscape(unsafe.Pointer(ep)), flags)
}
//go:nosplit
func HTMLEscape(s unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int) int {
return __HTMLEscape(rt.NoEscape(unsafe.Pointer(s)), nb, rt.NoEscape(unsafe.Pointer(dp)), rt.NoEscape(unsafe.Pointer(dn)))
}
//go:nosplit
func Value(s unsafe.Pointer, n int, p int, v *types.JsonState, flags uint64) int {
return __Value(rt.NoEscape(unsafe.Pointer(s)), n, p, rt.NoEscape(unsafe.Pointer(v)), flags)
}
//go:nosplit
func SkipOne(s *string, p *int, m *types.StateMachine, flags uint64) int {
return __SkipOne(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)), flags)
}
//go:nosplit
func SkipOneFast(s *string, p *int) int {
return __SkipOneFast(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)))
}
//go:nosplit
func GetByPath(s *string, p *int, path *[]interface{}, m *types.StateMachine) int {
return __GetByPath(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(path)), rt.NoEscape(unsafe.Pointer(m)))
}
//go:nosplit
func ValidateOne(s *string, p *int, m *types.StateMachine, flags uint64) int {
return __ValidateOne(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)), flags)
}
//go:nosplit
func I64toa(out *byte, val int64) (ret int) {
return __I64toa(rt.NoEscape(unsafe.Pointer(out)), val)
}
//go:nosplit
func U64toa(out *byte, val uint64) (ret int) {
return __U64toa(rt.NoEscape(unsafe.Pointer(out)), val)
}
//go:nosplit
func F64toa(out *byte, val float64) (ret int) {
return __F64toa(rt.NoEscape(unsafe.Pointer(out)), val)
}
//go:nosplit
func F32toa(out *byte, val float32) (ret int) {
return __F32toa(rt.NoEscape(unsafe.Pointer(out)), val)
}
//go:nosplit
func ValidateUTF8(s *string, p *int, m *types.StateMachine) (ret int) {
return __ValidateUTF8(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)))
}
//go:nosplit
func ValidateUTF8Fast(s *string) (ret int) {
return __ValidateUTF8Fast(rt.NoEscape(unsafe.Pointer(s)))
}
//go:nosplit
func ParseWithPadding(parser unsafe.Pointer) (ret int) {
return __ParseWithPadding(rt.NoEscape(unsafe.Pointer(parser)))
}
//go:nosplit
func LookupSmallKey(key *string, table *[]byte, lowerOff int) (index int) {
return __LookupSmallKey(rt.NoEscape(unsafe.Pointer(key)), rt.NoEscape(unsafe.Pointer(table)), lowerOff)
}
func useSSE() {
sse.Use()
S_f64toa = sse.S_f64toa
__F64toa = sse.F_f64toa
S_f32toa = sse.S_f32toa
__F32toa = sse.F_f32toa
S_i64toa = sse.S_i64toa
__I64toa = sse.F_i64toa
S_u64toa = sse.S_u64toa
__U64toa = sse.F_u64toa
S_lspace = sse.S_lspace
S_quote = sse.S_quote
__Quote = sse.F_quote
S_unquote = sse.S_unquote
__Unquote = sse.F_unquote
S_value = sse.S_value
__Value = sse.F_value
S_vstring = sse.S_vstring
S_vnumber = sse.S_vnumber
S_vsigned = sse.S_vsigned
S_vunsigned = sse.S_vunsigned
S_skip_one = sse.S_skip_one
__SkipOne = sse.F_skip_one
__SkipOneFast = sse.F_skip_one_fast
S_skip_array = sse.S_skip_array
S_skip_object = sse.S_skip_object
S_skip_number = sse.S_skip_number
S_get_by_path = sse.S_get_by_path
__GetByPath = sse.F_get_by_path
__HTMLEscape = sse.F_html_escape
__ValidateOne = sse.F_validate_one
__ValidateUTF8= sse.F_validate_utf8
__ValidateUTF8Fast = sse.F_validate_utf8_fast
__ParseWithPadding = sse.F_parse_with_padding
__LookupSmallKey = sse.F_lookup_small_key
}
func useAVX2() {
avx2.Use()
S_f64toa = avx2.S_f64toa
__F64toa = avx2.F_f64toa
S_f32toa = avx2.S_f32toa
__F32toa = avx2.F_f32toa
S_i64toa = avx2.S_i64toa
__I64toa = avx2.F_i64toa
S_u64toa = avx2.S_u64toa
__U64toa = avx2.F_u64toa
S_lspace = avx2.S_lspace
S_quote = avx2.S_quote
__Quote = avx2.F_quote
S_unquote = avx2.S_unquote
__Unquote = avx2.F_unquote
S_value = avx2.S_value
__Value = avx2.F_value
S_vstring = avx2.S_vstring
S_vnumber = avx2.S_vnumber
S_vsigned = avx2.S_vsigned
S_vunsigned = avx2.S_vunsigned
S_skip_one = avx2.S_skip_one
__SkipOne = avx2.F_skip_one
__SkipOneFast = avx2.F_skip_one_fast
S_skip_array = avx2.S_skip_array
S_skip_object = avx2.S_skip_object
S_skip_number = avx2.S_skip_number
S_get_by_path = avx2.S_get_by_path
__GetByPath = avx2.F_get_by_path
__HTMLEscape = avx2.F_html_escape
__ValidateOne = avx2.F_validate_one
__ValidateUTF8= avx2.F_validate_utf8
__ValidateUTF8Fast = avx2.F_validate_utf8_fast
__ParseWithPadding = avx2.F_parse_with_padding
__LookupSmallKey = avx2.F_lookup_small_key
}
func init() {
if cpu.HasAVX2 {
useAVX2()
} else if cpu.HasSSE {
useSSE()
} else {
panic("Unsupported CPU, lacks of AVX2 or SSE CPUID Flag. maybe it's too old to run Sonic.")
}
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/types/types.go | vendor/github.com/bytedance/sonic/internal/native/types/types.go | /*
* 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 types
import (
`fmt`
`sync`
`unsafe`
)
type ValueType = int64
type ParsingError uint
type SearchingError uint
// NOTE: !NOT MODIFIED ONLY.
// This definitions are followed in native/types.h.
const BufPaddingSize int = 64
const (
V_EOF ValueType = 1
V_NULL ValueType = 2
V_TRUE ValueType = 3
V_FALSE ValueType = 4
V_ARRAY ValueType = 5
V_OBJECT ValueType = 6
V_STRING ValueType = 7
V_DOUBLE ValueType = 8
V_INTEGER ValueType = 9
_ ValueType = 10 // V_KEY_SEP
_ ValueType = 11 // V_ELEM_SEP
_ ValueType = 12 // V_ARRAY_END
_ ValueType = 13 // V_OBJECT_END
V_MAX
)
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
// for native.SkipOne() flags
B_NO_VALIDATE_JSON= 6
)
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 (
MAX_RECURSE = 4096
)
const (
SPACE_MASK = (1 << ' ') | (1 << '\t') | (1 << '\r') | (1 << '\n')
)
const (
ERR_EOF ParsingError = 1
ERR_INVALID_CHAR ParsingError = 2
ERR_INVALID_ESCAPE ParsingError = 3
ERR_INVALID_UNICODE ParsingError = 4
ERR_INTEGER_OVERFLOW ParsingError = 5
ERR_INVALID_NUMBER_FMT ParsingError = 6
ERR_RECURSE_EXCEED_MAX ParsingError = 7
ERR_FLOAT_INFINITY ParsingError = 8
ERR_MISMATCH ParsingError = 9
ERR_INVALID_UTF8 ParsingError = 10
// error code used in ast
ERR_NOT_FOUND ParsingError = 33
ERR_UNSUPPORT_TYPE ParsingError = 34
)
var _ParsingErrors = []string{
0 : "ok",
ERR_EOF : "eof",
ERR_INVALID_CHAR : "invalid char",
ERR_INVALID_ESCAPE : "invalid escape char",
ERR_INVALID_UNICODE : "invalid unicode escape",
ERR_INTEGER_OVERFLOW : "integer overflow",
ERR_INVALID_NUMBER_FMT : "invalid number format",
ERR_RECURSE_EXCEED_MAX : "recursion exceeded max depth",
ERR_FLOAT_INFINITY : "float number is infinity",
ERR_MISMATCH : "mismatched type with value",
ERR_INVALID_UTF8 : "invalid UTF8",
}
func (self ParsingError) Error() string {
return "json: error when parsing input: " + self.Message()
}
func (self ParsingError) Message() string {
if int(self) < len(_ParsingErrors) {
return _ParsingErrors[self]
} else {
return fmt.Sprintf("unknown error %d", self)
}
}
type JsonState struct {
Vt ValueType
Dv float64
Iv int64
Ep int
Dbuf *byte
Dcap int
}
type StateMachine struct {
Sp int
Vt [MAX_RECURSE]int
}
var stackPool = sync.Pool{
New: func()interface{}{
return &StateMachine{}
},
}
func NewStateMachine() *StateMachine {
return stackPool.Get().(*StateMachine)
}
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)
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/parse_with_padding_text_amd64.go | vendor/github.com/bytedance/sonic/internal/native/sse/parse_with_padding_text_amd64.go | // +build amd64
// Code generated by asm2asm, DO NOT EDIT.
package sse
var _text_parse_with_padding = []byte{
// .p2align 4, 0x90
// _padding_reader_next
0x55, // pushq %rbp
0x48, 0x89, 0xe5, //0x00000001 movq %rsp, %rbp
0x48, 0x8b, 0x07, //0x00000004 movq (%rdi), %rax
0x48, 0x8d, 0x48, 0x01, //0x00000007 leaq $1(%rax), %rcx
0x48, 0x89, 0x0f, //0x0000000b movq %rcx, (%rdi)
0x0f, 0xbe, 0x00, //0x0000000e movsbl (%rax), %eax
0x5d, //0x00000011 popq %rbp
0xc3, //0x00000012 retq
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000013 .p2align 4, 0x90
//0x00000020 _padding_reader_peek_n
0x55, //0x00000020 pushq %rbp
0x48, 0x89, 0xe5, //0x00000021 movq %rsp, %rbp
0x48, 0x8b, 0x07, //0x00000024 movq (%rdi), %rax
0x5d, //0x00000027 popq %rbp
0xc3, //0x00000028 retq
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000029 .p2align 4, 0x90
//0x00000030 _padding_reader_cur
0x55, //0x00000030 pushq %rbp
0x48, 0x89, 0xe5, //0x00000031 movq %rsp, %rbp
0x48, 0x89, 0xf8, //0x00000034 movq %rdi, %rax
0x5d, //0x00000037 popq %rbp
0xc3, //0x00000038 retq
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000039 .p2align 4, 0x90
//0x00000040 _padding_reader_remain
0x55, //0x00000040 pushq %rbp
0x48, 0x89, 0xe5, //0x00000041 movq %rsp, %rbp
0x48, 0x8b, 0x47, 0x10, //0x00000044 movq $16(%rdi), %rax
0x48, 0x2b, 0x07, //0x00000048 subq (%rdi), %rax
0x5d, //0x0000004b popq %rbp
0xc3, //0x0000004c retq
0x90, 0x90, 0x90, //0x0000004d .p2align 4, 0x90
//0x00000050 _padding_reader_eat
0x55, //0x00000050 pushq %rbp
0x48, 0x89, 0xe5, //0x00000051 movq %rsp, %rbp
0x48, 0x01, 0x37, //0x00000054 addq %rsi, (%rdi)
0x5d, //0x00000057 popq %rbp
0xc3, //0x00000058 retq
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000059 .p2align 4, 0x00
//0x00000060 LCPI5_0
0x20, //0x00000060 .byte 32
0x00, //0x00000061 .byte 0
0x00, //0x00000062 .byte 0
0x00, //0x00000063 .byte 0
0x00, //0x00000064 .byte 0
0x00, //0x00000065 .byte 0
0x00, //0x00000066 .byte 0
0x00, //0x00000067 .byte 0
0x00, //0x00000068 .byte 0
0x09, //0x00000069 .byte 9
0x0a, //0x0000006a .byte 10
0x00, //0x0000006b .byte 0
0x00, //0x0000006c .byte 0
0x0d, //0x0000006d .byte 13
0x00, //0x0000006e .byte 0
0x00, //0x0000006f .byte 0
//0x00000070 LCPI5_1
0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, //0x00000070 QUAD $0x1f1f1f1f1f1f1f1f; QUAD $0x1f1f1f1f1f1f1f1f // .space 16, '\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f'
//0x00000080 LCPI5_2
0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, //0x00000080 QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""'
//0x00000090 LCPI5_3
0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, //0x00000090 QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
//0x000000a0 LCPI5_4
0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, //0x000000a0 QUAD $0x2f2f2f2f2f2f2f2f; QUAD $0x2f2f2f2f2f2f2f2f // .space 16, '////////////////'
//0x000000b0 LCPI5_5
0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, //0x000000b0 QUAD $0x3a3a3a3a3a3a3a3a; QUAD $0x3a3a3a3a3a3a3a3a // .space 16, '::::::::::::::::'
//0x000000c0 LCPI5_6
0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, //0x000000c0 QUAD $0x2b2b2b2b2b2b2b2b; QUAD $0x2b2b2b2b2b2b2b2b // .space 16, '++++++++++++++++'
//0x000000d0 LCPI5_7
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, //0x000000d0 QUAD $0x2d2d2d2d2d2d2d2d; QUAD $0x2d2d2d2d2d2d2d2d // .space 16, '----------------'
//0x000000e0 LCPI5_8
0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, //0x000000e0 QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf'
//0x000000f0 LCPI5_9
0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, //0x000000f0 QUAD $0x2e2e2e2e2e2e2e2e; QUAD $0x2e2e2e2e2e2e2e2e // .space 16, '................'
//0x00000100 LCPI5_10
0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, //0x00000100 QUAD $0x4545454545454545; QUAD $0x4545454545454545 // .space 16, 'EEEEEEEEEEEEEEEE'
//0x00000110 LCPI5_11
0x00, 0x00, 0x30, 0x43, //0x00000110 .long 1127219200
0x00, 0x00, 0x30, 0x45, //0x00000114 .long 1160773632
0x00, 0x00, 0x00, 0x00, //0x00000118 .long 0
0x00, 0x00, 0x00, 0x00, //0x0000011c .long 0
//0x00000120 LCPI5_12
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x43, //0x00000120 .quad 0x4330000000000000
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x45, //0x00000128 .quad 0x4530000000000000
//0x00000130 LCPI5_13
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, //0x00000130 .quad 0x8000000000000000
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, //0x00000138 .quad 0x8000000000000000
//0x00000140 .p2align 3, 0x00
//0x00000140 LCPI5_14
0x00, 0x00, 0x34, 0x26, 0xf5, 0x6b, 0x0c, 0x43, //0x00000140 .quad 0x430c6bf526340000
//0x00000148 LCPI5_15
0x00, 0x00, 0x34, 0x26, 0xf5, 0x6b, 0x0c, 0xc3, //0x00000148 .quad 0xc30c6bf526340000
//0x00000150 .p2align 4, 0x90
//0x00000150 _parse_with_padding
0x55, //0x00000150 pushq %rbp
0x48, 0x89, 0xe5, //0x00000151 movq %rsp, %rbp
0x41, 0x57, //0x00000154 pushq %r15
0x41, 0x56, //0x00000156 pushq %r14
0x41, 0x55, //0x00000158 pushq %r13
0x41, 0x54, //0x0000015a pushq %r12
0x53, //0x0000015c pushq %rbx
0x48, 0x81, 0xec, 0x90, 0x00, 0x00, 0x00, //0x0000015d subq $144, %rsp
0x49, 0x89, 0xfe, //0x00000164 movq %rdi, %r14
0x4c, 0x8b, 0x7f, 0x78, //0x00000167 movq $120(%rdi), %r15
0x48, 0x8b, 0x97, 0x80, 0x00, 0x00, 0x00, //0x0000016b movq $128(%rdi), %rdx
0x48, 0x8b, 0x87, 0x88, 0x00, 0x00, 0x00, //0x00000172 movq $136(%rdi), %rax
0x48, 0x89, 0x85, 0x68, 0xff, 0xff, 0xff, //0x00000179 movq %rax, $-152(%rbp)
0x48, 0x8b, 0xbf, 0xa8, 0x00, 0x00, 0x00, //0x00000180 movq $168(%rdi), %rdi
0x4d, 0x89, 0xfc, //0x00000187 movq %r15, %r12
0x49, 0xf7, 0xd4, //0x0000018a notq %r12
0x48, 0x83, 0xff, 0xff, //0x0000018d cmpq $-1, %rdi
0x0f, 0x85, 0x83, 0x2a, 0x00, 0x00, //0x00000191 jne LBB5_571
0x4c, 0x8d, 0x6a, 0x01, //0x00000197 leaq $1(%rdx), %r13
0x0f, 0xb6, 0x02, //0x0000019b movzbl (%rdx), %eax
0x48, 0x83, 0xf8, 0x20, //0x0000019e cmpq $32, %rax
0x0f, 0x87, 0x3a, 0x01, 0x00, 0x00, //0x000001a2 ja LBB5_13
0x48, 0xb9, 0x01, 0x26, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, //0x000001a8 movabsq $4294977025, %rcx
0x48, 0x0f, 0xa3, 0xc1, //0x000001b2 btq %rax, %rcx
0x0f, 0x83, 0x26, 0x01, 0x00, 0x00, //0x000001b6 jae LBB5_13
0x0f, 0xb6, 0x42, 0x01, //0x000001bc movzbl $1(%rdx), %eax
0x48, 0x83, 0xc2, 0x02, //0x000001c0 addq $2, %rdx
0x48, 0x83, 0xf8, 0x20, //0x000001c4 cmpq $32, %rax
0x0f, 0x87, 0x4b, 0x00, 0x00, 0x00, //0x000001c8 ja LBB5_35
0x48, 0x0f, 0xa3, 0xc1, //0x000001ce btq %rax, %rcx
0x0f, 0x83, 0x41, 0x00, 0x00, 0x00, //0x000001d2 jae LBB5_35
0x49, 0x8b, 0x86, 0x90, 0x00, 0x00, 0x00, //0x000001d8 movq $144(%r14), %rax
0x48, 0x89, 0xd1, //0x000001df movq %rdx, %rcx
0x48, 0x29, 0xc1, //0x000001e2 subq %rax, %rcx
0x48, 0x83, 0xf9, 0x40, //0x000001e5 cmpq $64, %rcx
0x0f, 0x83, 0x39, 0x00, 0x00, 0x00, //0x000001e9 jae LBB5_9
0x49, 0x8b, 0x96, 0x98, 0x00, 0x00, 0x00, //0x000001ef movq $152(%r14), %rdx
0x48, 0xd3, 0xea, //0x000001f6 shrq %cl, %rdx
0x48, 0xd3, 0xe2, //0x000001f9 shlq %cl, %rdx
0x48, 0x85, 0xd2, //0x000001fc testq %rdx, %rdx
0x0f, 0x84, 0x1c, 0x00, 0x00, 0x00, //0x000001ff je LBB5_8
0x48, 0x0f, 0xbc, 0xca, //0x00000205 bsfq %rdx, %rcx
0x4c, 0x8d, 0x2c, 0x08, //0x00000209 leaq (%rax,%rcx), %r13
0x49, 0x83, 0xc5, 0x01, //0x0000020d addq $1, %r13
0x48, 0x01, 0xc8, //0x00000211 addq %rcx, %rax
0xe9, 0xc7, 0x00, 0x00, 0x00, //0x00000214 jmp LBB5_12
//0x00000219 LBB5_35
0x49, 0x89, 0xd5, //0x00000219 movq %rdx, %r13
0xe9, 0xc1, 0x00, 0x00, 0x00, //0x0000021c jmp LBB5_13
//0x00000221 LBB5_8
0x48, 0x83, 0xc0, 0x40, //0x00000221 addq $64, %rax
0x48, 0x89, 0xc2, //0x00000225 movq %rax, %rdx
//0x00000228 LBB5_9
0x48, 0x83, 0xc2, 0xc0, //0x00000228 addq $-64, %rdx
0xf3, 0x44, 0x0f, 0x6f, 0x05, 0x2b, 0xfe, 0xff, 0xff, //0x0000022c movdqu $-469(%rip), %xmm8 /* LCPI5_0+0(%rip) */
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000235 .p2align 4, 0x90
//0x00000240 LBB5_10
0xf3, 0x0f, 0x6f, 0x4a, 0x40, //0x00000240 movdqu $64(%rdx), %xmm1
0xf3, 0x0f, 0x6f, 0x52, 0x50, //0x00000245 movdqu $80(%rdx), %xmm2
0xf3, 0x0f, 0x6f, 0x5a, 0x60, //0x0000024a movdqu $96(%rdx), %xmm3
0xf3, 0x0f, 0x6f, 0x62, 0x70, //0x0000024f movdqu $112(%rdx), %xmm4
0x48, 0x83, 0xc2, 0x40, //0x00000254 addq $64, %rdx
0x66, 0x41, 0x0f, 0x6f, 0xe8, //0x00000258 movdqa %xmm8, %xmm5
0x66, 0x0f, 0x38, 0x00, 0xe9, //0x0000025d pshufb %xmm1, %xmm5
0x66, 0x41, 0x0f, 0x6f, 0xf0, //0x00000262 movdqa %xmm8, %xmm6
0x66, 0x0f, 0x38, 0x00, 0xf2, //0x00000267 pshufb %xmm2, %xmm6
0x66, 0x41, 0x0f, 0x6f, 0xf8, //0x0000026c movdqa %xmm8, %xmm7
0x66, 0x0f, 0x38, 0x00, 0xfb, //0x00000271 pshufb %xmm3, %xmm7
0x66, 0x41, 0x0f, 0x6f, 0xc0, //0x00000276 movdqa %xmm8, %xmm0
0x66, 0x0f, 0x38, 0x00, 0xc4, //0x0000027b pshufb %xmm4, %xmm0
0x66, 0x0f, 0x74, 0xe9, //0x00000280 pcmpeqb %xmm1, %xmm5
0x66, 0x0f, 0xd7, 0xcd, //0x00000284 pmovmskb %xmm5, %ecx
0x66, 0x0f, 0x74, 0xf2, //0x00000288 pcmpeqb %xmm2, %xmm6
0x66, 0x0f, 0xd7, 0xf6, //0x0000028c pmovmskb %xmm6, %esi
0x66, 0x0f, 0x74, 0xfb, //0x00000290 pcmpeqb %xmm3, %xmm7
0x66, 0x0f, 0xd7, 0xff, //0x00000294 pmovmskb %xmm7, %edi
0x66, 0x0f, 0x74, 0xc4, //0x00000298 pcmpeqb %xmm4, %xmm0
0x66, 0x0f, 0xd7, 0xc0, //0x0000029c pmovmskb %xmm0, %eax
0x48, 0xc1, 0xe6, 0x10, //0x000002a0 shlq $16, %rsi
0x48, 0x09, 0xce, //0x000002a4 orq %rcx, %rsi
0x48, 0xc1, 0xe7, 0x20, //0x000002a7 shlq $32, %rdi
0x48, 0x09, 0xf7, //0x000002ab orq %rsi, %rdi
0x48, 0xc1, 0xe0, 0x30, //0x000002ae shlq $48, %rax
0x48, 0x09, 0xf8, //0x000002b2 orq %rdi, %rax
0x48, 0x83, 0xf8, 0xff, //0x000002b5 cmpq $-1, %rax
0x0f, 0x84, 0x81, 0xff, 0xff, 0xff, //0x000002b9 je LBB5_10
0x48, 0xf7, 0xd0, //0x000002bf notq %rax
0x49, 0x89, 0x86, 0x98, 0x00, 0x00, 0x00, //0x000002c2 movq %rax, $152(%r14)
0x49, 0x89, 0x96, 0x90, 0x00, 0x00, 0x00, //0x000002c9 movq %rdx, $144(%r14)
0x48, 0x0f, 0xbc, 0xc8, //0x000002d0 bsfq %rax, %rcx
0x48, 0x8d, 0x04, 0x0a, //0x000002d4 leaq (%rdx,%rcx), %rax
0x4c, 0x8d, 0x2c, 0x0a, //0x000002d8 leaq (%rdx,%rcx), %r13
0x49, 0x83, 0xc5, 0x01, //0x000002dc addq $1, %r13
//0x000002e0 LBB5_12
0x8a, 0x00, //0x000002e0 movb (%rax), %al
//0x000002e2 LBB5_13
0x0f, 0xbe, 0xc0, //0x000002e2 movsbl %al, %eax
0x41, 0xb8, 0x06, 0x00, 0x00, 0x00, //0x000002e5 movl $6, %r8d
0x83, 0xc0, 0xde, //0x000002eb addl $-34, %eax
0x83, 0xf8, 0x59, //0x000002ee cmpl $89, %eax
0x0f, 0x87, 0x43, 0x09, 0x00, 0x00, //0x000002f1 ja LBB5_149
0x4f, 0x8d, 0x1c, 0x2c, //0x000002f7 leaq (%r12,%r13), %r11
0x31, 0xd2, //0x000002fb xorl %edx, %edx
0x48, 0x8d, 0x0d, 0xdc, 0xb8, 0x00, 0x00, //0x000002fd leaq $47324(%rip), %rcx /* LJTI5_0+0(%rip) */
0x48, 0x63, 0x04, 0x81, //0x00000304 movslq (%rcx,%rax,4), %rax
0x48, 0x01, 0xc8, //0x00000308 addq %rcx, %rax
0xff, 0xe0, //0x0000030b jmpq *%rax
//0x0000030d LBB5_16
0x89, 0xd0, //0x0000030d movl %edx, %eax
0x34, 0x01, //0x0000030f xorb $1, %al
0x44, 0x0f, 0xb6, 0xc8, //0x00000311 movzbl %al, %r9d
0x4d, 0x89, 0xec, //0x00000315 movq %r13, %r12
0x4d, 0x29, 0xcc, //0x00000318 subq %r9, %r12
0x41, 0xf6, 0x46, 0x70, 0x02, //0x0000031b testb $2, $112(%r14)
0x0f, 0x85, 0x48, 0x00, 0x00, 0x00, //0x00000320 jne LBB5_23
0x41, 0x8a, 0x04, 0x24, //0x00000326 movb (%r12), %al
0x3c, 0x30, //0x0000032a cmpb $48, %al
0x0f, 0x85, 0x85, 0x00, 0x00, 0x00, //0x0000032c jne LBB5_27
0x41, 0x8a, 0x44, 0x24, 0x01, //0x00000332 movb $1(%r12), %al
0x3c, 0x2e, //0x00000337 cmpb $46, %al
0x0f, 0x84, 0x51, 0x07, 0x00, 0x00, //0x00000339 je LBB5_123
0x4d, 0x8d, 0x6c, 0x24, 0x01, //0x0000033f leaq $1(%r12), %r13
0x45, 0x31, 0xd2, //0x00000344 xorl %r10d, %r10d
0x3c, 0x45, //0x00000347 cmpb $69, %al
0x0f, 0x84, 0x2f, 0x09, 0x00, 0x00, //0x00000349 je LBB5_153
0x3c, 0x65, //0x0000034f cmpb $101, %al
0x0f, 0x84, 0x27, 0x09, 0x00, 0x00, //0x00000351 je LBB5_153
0x31, 0xc0, //0x00000357 xorl %eax, %eax
0x84, 0xd2, //0x00000359 testb %dl, %dl
0x0f, 0x84, 0xc2, 0x0d, 0x00, 0x00, //0x0000035b je LBB5_215
//0x00000361 LBB5_22
0x49, 0xc1, 0xe3, 0x20, //0x00000361 shlq $32, %r11
0x49, 0x83, 0xcb, 0x0b, //0x00000365 orq $11, %r11
0xe9, 0xbd, 0x0d, 0x00, 0x00, //0x00000369 jmp LBB5_216
//0x0000036e LBB5_23
0x4c, 0x89, 0x5d, 0xb8, //0x0000036e movq %r11, $-72(%rbp)
0x4c, 0x89, 0x6d, 0xc8, //0x00000372 movq %r13, $-56(%rbp)
0x4c, 0x89, 0x75, 0xb0, //0x00000376 movq %r14, $-80(%rbp)
0x49, 0xf7, 0xd9, //0x0000037a negq %r9
0x4c, 0x8b, 0xad, 0x68, 0xff, 0xff, 0xff, //0x0000037d movq $-152(%rbp), %r13
0x4d, 0x29, 0xe5, //0x00000384 subq %r12, %r13
0x4d, 0x29, 0xcd, //0x00000387 subq %r9, %r13
0x0f, 0x84, 0xb7, 0x00, 0x00, 0x00, //0x0000038a je LBB5_34
0x41, 0x80, 0x3c, 0x24, 0x30, //0x00000390 cmpb $48, (%r12)
0x0f, 0x85, 0x42, 0x04, 0x00, 0x00, //0x00000395 jne LBB5_80
0x45, 0x31, 0xc0, //0x0000039b xorl %r8d, %r8d
0xb8, 0x01, 0x00, 0x00, 0x00, //0x0000039e movl $1, %eax
0x49, 0x83, 0xfd, 0x01, //0x000003a3 cmpq $1, %r13
0x0f, 0x85, 0x03, 0x04, 0x00, 0x00, //0x000003a7 jne LBB5_78
//0x000003ad LBB5_26
0xb9, 0x01, 0x00, 0x00, 0x00, //0x000003ad movl $1, %ecx
0xe9, 0x1d, 0x08, 0x00, 0x00, //0x000003b2 jmp LBB5_145
//0x000003b7 LBB5_27
0x8d, 0x48, 0xd0, //0x000003b7 leal $-48(%rax), %ecx
0x41, 0xb8, 0x03, 0x00, 0x00, 0x00, //0x000003ba movl $3, %r8d
0x80, 0xf9, 0x09, //0x000003c0 cmpb $9, %cl
0x0f, 0x87, 0x52, 0xab, 0x00, 0x00, //0x000003c3 ja LBB5_2239
0x48, 0xc7, 0xc7, 0xff, 0xff, 0xff, 0xff, //0x000003c9 movq $-1, %rdi
0x31, 0xc9, //0x000003d0 xorl %ecx, %ecx
0x31, 0xf6, //0x000003d2 xorl %esi, %esi
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x000003d4 .p2align 4, 0x90
//0x000003e0 LBB5_29
0x48, 0x8d, 0x34, 0xb6, //0x000003e0 leaq (%rsi,%rsi,4), %rsi
0x0f, 0xb6, 0xc0, //0x000003e4 movzbl %al, %eax
0x48, 0x8d, 0x34, 0x70, //0x000003e7 leaq (%rax,%rsi,2), %rsi
0x48, 0x83, 0xc6, 0xd0, //0x000003eb addq $-48, %rsi
0x41, 0x0f, 0xb6, 0x44, 0x3c, 0x02, //0x000003ef movzbl $2(%r12,%rdi), %eax
0x8d, 0x58, 0xd0, //0x000003f5 leal $-48(%rax), %ebx
0x48, 0x83, 0xc1, 0xff, //0x000003f8 addq $-1, %rcx
0x48, 0x83, 0xc7, 0x01, //0x000003fc addq $1, %rdi
0x80, 0xfb, 0x0a, //0x00000400 cmpb $10, %bl
0x0f, 0x82, 0xd7, 0xff, 0xff, 0xff, //0x00000403 jb LBB5_29
0x4d, 0x89, 0xe5, //0x00000409 movq %r12, %r13
0x49, 0x29, 0xcd, //0x0000040c subq %rcx, %r13
0x48, 0x83, 0xff, 0x13, //0x0000040f cmpq $19, %rdi
0x0f, 0x83, 0x9b, 0x2a, 0x00, 0x00, //0x00000413 jae LBB5_602
0x48, 0xf7, 0xd9, //0x00000419 negq %rcx
0x45, 0x31, 0xd2, //0x0000041c xorl %r10d, %r10d
0x45, 0x31, 0xff, //0x0000041f xorl %r15d, %r15d
//0x00000422 LBB5_32
0x3c, 0x2e, //0x00000422 cmpb $46, %al
0x0f, 0x85, 0x23, 0x07, 0x00, 0x00, //0x00000424 jne LBB5_135
0x4c, 0x89, 0x55, 0xc0, //0x0000042a movq %r10, $-64(%rbp)
0x41, 0x8a, 0x45, 0x01, //0x0000042e movb $1(%r13), %al
0x49, 0x83, 0xc5, 0x01, //0x00000432 addq $1, %r13
0x8d, 0x58, 0xd0, //0x00000436 leal $-48(%rax), %ebx
0x80, 0xfb, 0x0a, //0x00000439 cmpb $10, %bl
0x0f, 0x82, 0xa1, 0x06, 0x00, 0x00, //0x0000043c jb LBB5_129
0xe9, 0xf3, 0x07, 0x00, 0x00, //0x00000442 jmp LBB5_149
//0x00000447 LBB5_34
0x48, 0xc7, 0xc0, 0xff, 0xff, 0xff, 0xff, //0x00000447 movq $-1, %rax
0xe9, 0x71, 0x07, 0x00, 0x00, //0x0000044e jmp LBB5_144
//0x00000453 LBB5_36
0x41, 0x80, 0x7d, 0x00, 0x75, //0x00000453 cmpb $117, (%r13)
0x41, 0xb8, 0x0d, 0x00, 0x00, 0x00, //0x00000458 movl $13, %r8d
0x0f, 0x85, 0x7a, 0x2b, 0x00, 0x00, //0x0000045e jne LBB5_617
0x41, 0x80, 0x7d, 0x01, 0x6c, //0x00000464 cmpb $108, $1(%r13)
0x0f, 0x85, 0x41, 0x2c, 0x00, 0x00, //0x00000469 jne LBB5_625
0x45, 0x31, 0xc0, //0x0000046f xorl %r8d, %r8d
0x41, 0x80, 0x7d, 0x02, 0x6c, //0x00000472 cmpb $108, $2(%r13)
0x0f, 0x85, 0x57, 0x2c, 0x00, 0x00, //0x00000477 jne LBB5_628
//0x0000047d LBB5_39
0x4d, 0x89, 0xec, //0x0000047d movq %r13, %r12
0x49, 0x83, 0xc4, 0x03, //0x00000480 addq $3, %r12
//0x00000484 LBB5_40
0x49, 0xc1, 0xe3, 0x20, //0x00000484 shlq $32, %r11
0xe9, 0x03, 0x02, 0x00, 0x00, //0x00000488 jmp LBB5_67
//0x0000048d LBB5_41
0x41, 0x80, 0x7d, 0x00, 0x72, //0x0000048d cmpb $114, (%r13)
0x41, 0xb8, 0x0d, 0x00, 0x00, 0x00, //0x00000492 movl $13, %r8d
0x0f, 0x85, 0x4c, 0x2b, 0x00, 0x00, //0x00000498 jne LBB5_618
0x41, 0x80, 0x7d, 0x01, 0x75, //0x0000049e cmpb $117, $1(%r13)
0x0f, 0x85, 0x13, 0x2c, 0x00, 0x00, //0x000004a3 jne LBB5_626
0x45, 0x31, 0xc0, //0x000004a9 xorl %r8d, %r8d
0x41, 0x80, 0x7d, 0x02, 0x65, //0x000004ac cmpb $101, $2(%r13)
0x0f, 0x85, 0x28, 0x2c, 0x00, 0x00, //0x000004b1 jne LBB5_629
//0x000004b7 LBB5_44
0x4d, 0x89, 0xec, //0x000004b7 movq %r13, %r12
0x49, 0x83, 0xc4, 0x03, //0x000004ba addq $3, %r12
//0x000004be LBB5_45
0x49, 0xc1, 0xe3, 0x20, //0x000004be shlq $32, %r11
0x49, 0x83, 0xcb, 0x0a, //0x000004c2 orq $10, %r11
0xe9, 0xc5, 0x01, 0x00, 0x00, //0x000004c6 jmp LBB5_67
//0x000004cb LBB5_46
0x49, 0x8b, 0x4e, 0x70, //0x000004cb movq $112(%r14), %rcx
0xf6, 0xc1, 0x20, //0x000004cf testb $32, %cl
0x0f, 0x85, 0x1e, 0x2b, 0x00, 0x00, //0x000004d2 jne LBB5_619
0xf3, 0x0f, 0x6f, 0x05, 0xa0, 0xfb, 0xff, 0xff, //0x000004d8 movdqu $-1120(%rip), %xmm0 /* LCPI5_2+0(%rip) */
0xf3, 0x0f, 0x6f, 0x0d, 0xa8, 0xfb, 0xff, 0xff, //0x000004e0 movdqu $-1112(%rip), %xmm1 /* LCPI5_3+0(%rip) */
0x4c, 0x89, 0xe8, //0x000004e8 movq %r13, %rax
0x90, 0x90, 0x90, 0x90, 0x90, //0x000004eb .p2align 4, 0x90
//0x000004f0 LBB5_48
0xf3, 0x0f, 0x6f, 0x10, //0x000004f0 movdqu (%rax), %xmm2
0xf3, 0x0f, 0x6f, 0x58, 0x10, //0x000004f4 movdqu $16(%rax), %xmm3
0x66, 0x0f, 0x6f, 0xe3, //0x000004f9 movdqa %xmm3, %xmm4
0x66, 0x0f, 0x74, 0xe0, //0x000004fd pcmpeqb %xmm0, %xmm4
0x66, 0x0f, 0xd7, 0xf4, //0x00000501 pmovmskb %xmm4, %esi
0x66, 0x0f, 0x6f, 0xe2, //0x00000505 movdqa %xmm2, %xmm4
0x66, 0x0f, 0x74, 0xe0, //0x00000509 pcmpeqb %xmm0, %xmm4
0x66, 0x0f, 0xd7, 0xdc, //0x0000050d pmovmskb %xmm4, %ebx
0x66, 0x0f, 0x74, 0xd9, //0x00000511 pcmpeqb %xmm1, %xmm3
0x66, 0x0f, 0xd7, 0xfb, //0x00000515 pmovmskb %xmm3, %edi
0xc1, 0xe7, 0x10, //0x00000519 shll $16, %edi
0x66, 0x0f, 0x74, 0xd1, //0x0000051c pcmpeqb %xmm1, %xmm2
0x66, 0x0f, 0xd7, 0xd2, //0x00000520 pmovmskb %xmm2, %edx
0xc1, 0xe6, 0x10, //0x00000524 shll $16, %esi
0x09, 0xde, //0x00000527 orl %ebx, %esi
0x8d, 0x1c, 0x17, //0x00000529 leal (%rdi,%rdx), %ebx
0x83, 0xc3, 0xff, //0x0000052c addl $-1, %ebx
0x85, 0xf3, //0x0000052f testl %esi, %ebx
0x0f, 0x85, 0xd0, 0x2b, 0x00, 0x00, //0x00000531 jne LBB5_633
0x09, 0xd7, //0x00000537 orl %edx, %edi
0x83, 0xc6, 0xff, //0x00000539 addl $-1, %esi
0x85, 0xfe, //0x0000053c testl %edi, %esi
0x0f, 0x85, 0xb7, 0x30, 0x00, 0x00, //0x0000053e jne LBB5_685
0x48, 0x83, 0xc0, 0x20, //0x00000544 addq $32, %rax
0xe9, 0xa3, 0xff, 0xff, 0xff, //0x00000548 jmp LBB5_48
//0x0000054d LBB5_51
0x49, 0xc1, 0xe3, 0x20, //0x0000054d shlq $32, %r11
0x49, 0x83, 0xcb, 0x06, //0x00000551 orq $6, %r11
0x49, 0x8b, 0x86, 0xa0, 0x00, 0x00, 0x00, //0x00000555 movq $160(%r14), %rax
0x4c, 0x89, 0x18, //0x0000055c movq %r11, (%rax)
0x48, 0xc7, 0x40, 0x08, 0xff, 0xff, 0xff, 0xff, //0x0000055f movq $-1, $8(%rax)
0x49, 0x8b, 0x96, 0xa0, 0x00, 0x00, 0x00, //0x00000567 movq $160(%r14), %rdx
0x4d, 0x8b, 0x86, 0xb8, 0x00, 0x00, 0x00, //0x0000056e movq $184(%r14), %r8
0x48, 0x89, 0xd0, //0x00000575 movq %rdx, %rax
0x4c, 0x29, 0xc0, //0x00000578 subq %r8, %rax
0x48, 0x89, 0xc7, //0x0000057b movq %rax, %rdi
0x48, 0xc1, 0xff, 0x04, //0x0000057e sarq $4, %rdi
0x49, 0x89, 0xbe, 0xa8, 0x00, 0x00, 0x00, //0x00000582 movq %rdi, $168(%r14)
0x4c, 0x8d, 0x4a, 0x10, //0x00000589 leaq $16(%rdx), %r9
0x4d, 0x89, 0x8e, 0xa0, 0x00, 0x00, 0x00, //0x0000058d movq %r9, $160(%r14)
0x49, 0x83, 0x86, 0xb0, 0x00, 0x00, 0x00, 0x01, //0x00000594 addq $1, $176(%r14)
0x48, 0x8d, 0x4a, 0x20, //0x0000059c leaq $32(%rdx), %rcx
0x45, 0x31, 0xdb, //0x000005a0 xorl %r11d, %r11d
0x48, 0x83, 0xf8, 0xf0, //0x000005a3 cmpq $-16, %rax
0x48, 0x89, 0xd0, //0x000005a7 movq %rdx, %rax
0x49, 0x0f, 0x44, 0xc3, //0x000005aa cmoveq %r11, %rax
0x49, 0x3b, 0x8e, 0xc0, 0x00, 0x00, 0x00, //0x000005ae cmpq $192(%r14), %rcx
0x0f, 0x87, 0x03, 0x00, 0x00, 0x00, //0x000005b5 ja LBB5_53
0x49, 0x89, 0xc3, //0x000005bb movq %rax, %r11
//0x000005be LBB5_53
0x4d, 0x85, 0xdb, //0x000005be testq %r11, %r11
0x0f, 0x84, 0x75, 0x38, 0x00, 0x00, //0x000005c1 je LBB5_309
0x49, 0x8d, 0x45, 0x01, //0x000005c7 leaq $1(%r13), %rax
0x41, 0x0f, 0xb6, 0x4d, 0x00, //0x000005cb movzbl (%r13), %ecx
0x48, 0x83, 0xf9, 0x20, //0x000005d0 cmpq $32, %rcx
0x0f, 0x87, 0x8b, 0x0c, 0x00, 0x00, //0x000005d4 ja LBB5_226
0x48, 0xbe, 0x01, 0x26, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, //0x000005da movabsq $4294977025, %rsi
0x48, 0x0f, 0xa3, 0xce, //0x000005e4 btq %rcx, %rsi
0x0f, 0x83, 0x77, 0x0c, 0x00, 0x00, //0x000005e8 jae LBB5_226
0x41, 0x0f, 0xb6, 0x4d, 0x01, //0x000005ee movzbl $1(%r13), %ecx
0x49, 0x83, 0xc5, 0x02, //0x000005f3 addq $2, %r13
0x48, 0x83, 0xf9, 0x20, //0x000005f7 cmpq $32, %rcx
0x0f, 0x87, 0x85, 0x0b, 0x00, 0x00, //0x000005fb ja LBB5_257
0x48, 0x0f, 0xa3, 0xce, //0x00000601 btq %rcx, %rsi
0x0f, 0x83, 0x7b, 0x0b, 0x00, 0x00, //0x00000605 jae LBB5_257
0x49, 0x8b, 0xb6, 0x90, 0x00, 0x00, 0x00, //0x0000060b movq $144(%r14), %rsi
0x4c, 0x89, 0xe9, //0x00000612 movq %r13, %rcx
0x48, 0x29, 0xf1, //0x00000615 subq %rsi, %rcx
0x48, 0x83, 0xf9, 0x40, //0x00000618 cmpq $64, %rcx
0x0f, 0x83, 0x86, 0x0b, 0x00, 0x00, //0x0000061c jae LBB5_222
0x49, 0x8b, 0x86, 0x98, 0x00, 0x00, 0x00, //0x00000622 movq $152(%r14), %rax
0x48, 0xd3, 0xe8, //0x00000629 shrq %cl, %rax
0x48, 0xd3, 0xe0, //0x0000062c shlq %cl, %rax
0x48, 0x85, 0xc0, //0x0000062f testq %rax, %rax
0x0f, 0x84, 0x69, 0x0b, 0x00, 0x00, //0x00000632 je LBB5_221
0x48, 0x0f, 0xbc, 0xc8, //0x00000638 bsfq %rax, %rcx
0x48, 0x8d, 0x04, 0x0e, //0x0000063c leaq (%rsi,%rcx), %rax
0x48, 0x83, 0xc0, 0x01, //0x00000640 addq $1, %rax
0x48, 0x01, 0xce, //0x00000644 addq %rcx, %rsi
0xe9, 0x17, 0x0c, 0x00, 0x00, //0x00000647 jmp LBB5_225
//0x0000064c LBB5_61
0x41, 0x80, 0x7d, 0x00, 0x61, //0x0000064c cmpb $97, (%r13)
0x41, 0xb8, 0x0d, 0x00, 0x00, 0x00, //0x00000651 movl $13, %r8d
0x0f, 0x85, 0x47, 0x2a, 0x00, 0x00, //0x00000657 jne LBB5_624
0x41, 0x80, 0x7d, 0x01, 0x6c, //0x0000065d cmpb $108, $1(%r13)
0x0f, 0x85, 0x60, 0x2a, 0x00, 0x00, //0x00000662 jne LBB5_627
0x41, 0x80, 0x7d, 0x02, 0x73, //0x00000668 cmpb $115, $2(%r13)
0x0f, 0x85, 0x77, 0x2a, 0x00, 0x00, //0x0000066d jne LBB5_630
0x45, 0x31, 0xc0, //0x00000673 xorl %r8d, %r8d
0x41, 0x80, 0x7d, 0x03, 0x65, //0x00000676 cmpb $101, $3(%r13)
0x0f, 0x85, 0x75, 0x2a, 0x00, 0x00, //0x0000067b jne LBB5_631
//0x00000681 LBB5_65
0x4d, 0x89, 0xec, //0x00000681 movq %r13, %r12
0x49, 0x83, 0xc4, 0x04, //0x00000684 addq $4, %r12
//0x00000688 LBB5_66
0x49, 0xc1, 0xe3, 0x20, //0x00000688 shlq $32, %r11
0x49, 0x83, 0xcb, 0x02, //0x0000068c orq $2, %r11
//0x00000690 LBB5_67
0x49, 0x8b, 0x86, 0xa0, 0x00, 0x00, 0x00, //0x00000690 movq $160(%r14), %rax
0x4c, 0x89, 0x18, //0x00000697 movq %r11, (%rax)
0x48, 0x8d, 0x48, 0x10, //0x0000069a leaq $16(%rax), %rcx
0x49, 0x89, 0x8e, 0xa0, 0x00, 0x00, 0x00, //0x0000069e movq %rcx, $160(%r14)
0xe9, 0x6b, 0x05, 0x00, 0x00, //0x000006a5 jmp LBB5_146
//0x000006aa LBB5_15
0xb2, 0x01, //0x000006aa movb $1, %dl
0xe9, 0x5c, 0xfc, 0xff, 0xff, //0x000006ac jmp LBB5_16
//0x000006b1 LBB5_68
0x49, 0xc1, 0xe3, 0x20, //0x000006b1 shlq $32, %r11
0x49, 0x83, 0xcb, 0x07, //0x000006b5 orq $7, %r11
0x49, 0x8b, 0x86, 0xa0, 0x00, 0x00, 0x00, //0x000006b9 movq $160(%r14), %rax
0x4c, 0x89, 0x18, //0x000006c0 movq %r11, (%rax)
0x48, 0xc7, 0x40, 0x08, 0xff, 0xff, 0xff, 0xff, //0x000006c3 movq $-1, $8(%rax)
0x49, 0x8b, 0x96, 0xa0, 0x00, 0x00, 0x00, //0x000006cb movq $160(%r14), %rdx
0x4d, 0x8b, 0x86, 0xb8, 0x00, 0x00, 0x00, //0x000006d2 movq $184(%r14), %r8
0x48, 0x89, 0xd0, //0x000006d9 movq %rdx, %rax
0x4c, 0x29, 0xc0, //0x000006dc subq %r8, %rax
0x49, 0x89, 0xc2, //0x000006df movq %rax, %r10
0x49, 0xc1, 0xfa, 0x04, //0x000006e2 sarq $4, %r10
0x4d, 0x89, 0x96, 0xa8, 0x00, 0x00, 0x00, //0x000006e6 movq %r10, $168(%r14)
0x4c, 0x8d, 0x4a, 0x10, //0x000006ed leaq $16(%rdx), %r9
0x4d, 0x89, 0x8e, 0xa0, 0x00, 0x00, 0x00, //0x000006f1 movq %r9, $160(%r14)
0x49, 0x83, 0x86, 0xb0, 0x00, 0x00, 0x00, 0x01, //0x000006f8 addq $1, $176(%r14)
0x48, 0x8d, 0x4a, 0x20, //0x00000700 leaq $32(%rdx), %rcx
0x45, 0x31, 0xdb, //0x00000704 xorl %r11d, %r11d
0x48, 0x83, 0xf8, 0xf0, //0x00000707 cmpq $-16, %rax
0x48, 0x89, 0xd0, //0x0000070b movq %rdx, %rax
0x49, 0x0f, 0x44, 0xc3, //0x0000070e cmoveq %r11, %rax
0x49, 0x3b, 0x8e, 0xc0, 0x00, 0x00, 0x00, //0x00000712 cmpq $192(%r14), %rcx
0x0f, 0x87, 0x03, 0x00, 0x00, 0x00, //0x00000719 ja LBB5_70
0x49, 0x89, 0xc3, //0x0000071f movq %rax, %r11
//0x00000722 LBB5_70
0x4d, 0x85, 0xdb, //0x00000722 testq %r11, %r11
0x0f, 0x84, 0x11, 0x37, 0x00, 0x00, //0x00000725 je LBB5_309
0x49, 0x8d, 0x45, 0x01, //0x0000072b leaq $1(%r13), %rax
0x41, 0x0f, 0xb6, 0x4d, 0x00, //0x0000072f movzbl (%r13), %ecx
0x48, 0x83, 0xf9, 0x20, //0x00000734 cmpq $32, %rcx
0x0f, 0x87, 0x33, 0x0c, 0x00, 0x00, //0x00000738 ja LBB5_234
0x48, 0xbe, 0x01, 0x26, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, //0x0000073e movabsq $4294977025, %rsi
0x48, 0x0f, 0xa3, 0xce, //0x00000748 btq %rcx, %rsi
0x0f, 0x83, 0x1f, 0x0c, 0x00, 0x00, //0x0000074c jae LBB5_234
0x41, 0x0f, 0xb6, 0x4d, 0x01, //0x00000752 movzbl $1(%r13), %ecx
0x49, 0x83, 0xc5, 0x02, //0x00000757 addq $2, %r13
0x48, 0x83, 0xf9, 0x20, //0x0000075b cmpq $32, %rcx
0x0f, 0x87, 0x29, 0x0a, 0x00, 0x00, //0x0000075f ja LBB5_258
0x48, 0x0f, 0xa3, 0xce, //0x00000765 btq %rcx, %rsi
0x0f, 0x83, 0x1f, 0x0a, 0x00, 0x00, //0x00000769 jae LBB5_258
0x49, 0x8b, 0xb6, 0x90, 0x00, 0x00, 0x00, //0x0000076f movq $144(%r14), %rsi
0x4c, 0x89, 0xe9, //0x00000776 movq %r13, %rcx
0x48, 0x29, 0xf1, //0x00000779 subq %rsi, %rcx
0x48, 0x83, 0xf9, 0x40, //0x0000077c cmpq $64, %rcx
0x0f, 0x83, 0x35, 0x0b, 0x00, 0x00, //0x00000780 jae LBB5_230
0x49, 0x8b, 0x86, 0x98, 0x00, 0x00, 0x00, //0x00000786 movq $152(%r14), %rax
0x48, 0xd3, 0xe8, //0x0000078d shrq %cl, %rax
0x48, 0xd3, 0xe0, //0x00000790 shlq %cl, %rax
0x48, 0x85, 0xc0, //0x00000793 testq %rax, %rax
0x0f, 0x84, 0x18, 0x0b, 0x00, 0x00, //0x00000796 je LBB5_229
0x48, 0x0f, 0xbc, 0xc8, //0x0000079c bsfq %rax, %rcx
0x48, 0x8d, 0x04, 0x0e, //0x000007a0 leaq (%rsi,%rcx), %rax
0x48, 0x83, 0xc0, 0x01, //0x000007a4 addq $1, %rax
0x48, 0x01, 0xce, //0x000007a8 addq %rcx, %rsi
0xe9, 0xbf, 0x0b, 0x00, 0x00, //0x000007ab jmp LBB5_233
//0x000007b0 LBB5_78
0x41, 0x8a, 0x4c, 0x24, 0x01, //0x000007b0 movb $1(%r12), %cl
0x80, 0xc1, 0xd2, //0x000007b5 addb $-46, %cl
0x80, 0xf9, 0x37, //0x000007b8 cmpb $55, %cl
0x0f, 0x87, 0xec, 0xfb, 0xff, 0xff, //0x000007bb ja LBB5_26
0x0f, 0xb6, 0xc9, //0x000007c1 movzbl %cl, %ecx
0x48, 0xbe, 0x01, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, //0x000007c4 movabsq $36028797027352577, %rsi
0x48, 0x0f, 0xa3, 0xce, //0x000007ce btq %rcx, %rsi
0xb9, 0x01, 0x00, 0x00, 0x00, //0x000007d2 movl $1, %ecx
0x0f, 0x83, 0xf7, 0x03, 0x00, 0x00, //0x000007d7 jae LBB5_145
//0x000007dd LBB5_80
0x41, 0x89, 0xd0, //0x000007dd movl %edx, %r8d
0x49, 0x83, 0xfd, 0x10, //0x000007e0 cmpq $16, %r13
0x0f, 0x82, 0xa0, 0x26, 0x00, 0x00, //0x000007e4 jb LBB5_600
0x45, 0x89, 0xca, //0x000007ea movl %r9d, %r10d
0x41, 0x83, 0xe2, 0x01, //0x000007ed andl $1, %r10d
0x49, 0xc7, 0xc7, 0xff, 0xff, 0xff, 0xff, //0x000007f1 movq $-1, %r15
0x31, 0xc0, //0x000007f8 xorl %eax, %eax
0xf3, 0x44, 0x0f, 0x6f, 0x05, 0x9d, 0xf8, 0xff, 0xff, //0x000007fa movdqu $-1891(%rip), %xmm8 /* LCPI5_4+0(%rip) */
0xf3, 0x44, 0x0f, 0x6f, 0x15, 0xa4, 0xf8, 0xff, 0xff, //0x00000803 movdqu $-1884(%rip), %xmm10 /* LCPI5_5+0(%rip) */
0xf3, 0x44, 0x0f, 0x6f, 0x0d, 0xab, 0xf8, 0xff, 0xff, //0x0000080c movdqu $-1877(%rip), %xmm9 /* LCPI5_6+0(%rip) */
0xf3, 0x0f, 0x6f, 0x1d, 0xb3, 0xf8, 0xff, 0xff, //0x00000815 movdqu $-1869(%rip), %xmm3 /* LCPI5_7+0(%rip) */
0xf3, 0x0f, 0x6f, 0x25, 0xbb, 0xf8, 0xff, 0xff, //0x0000081d movdqu $-1861(%rip), %xmm4 /* LCPI5_8+0(%rip) */
0xf3, 0x0f, 0x6f, 0x2d, 0xc3, 0xf8, 0xff, 0xff, //0x00000825 movdqu $-1853(%rip), %xmm5 /* LCPI5_9+0(%rip) */
0xf3, 0x0f, 0x6f, 0x35, 0xcb, 0xf8, 0xff, 0xff, //0x0000082d movdqu $-1845(%rip), %xmm6 /* LCPI5_10+0(%rip) */
0x49, 0xc7, 0xc6, 0xff, 0xff, 0xff, 0xff, //0x00000835 movq $-1, %r14
0x49, 0xc7, 0xc3, 0xff, 0xff, 0xff, 0xff, //0x0000083c movq $-1, %r11
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000843 .p2align 4, 0x90
//0x00000850 LBB5_82
0xf3, 0x41, 0x0f, 0x6f, 0x3c, 0x04, //0x00000850 movdqu (%r12,%rax), %xmm7
0x66, 0x0f, 0x6f, 0xc7, //0x00000856 movdqa %xmm7, %xmm0
0x66, 0x41, 0x0f, 0x64, 0xc0, //0x0000085a pcmpgtb %xmm8, %xmm0
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | true |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/skip_object_text_amd64.go | vendor/github.com/bytedance/sonic/internal/native/sse/skip_object_text_amd64.go | // +build amd64
// Code generated by asm2asm, DO NOT EDIT.
package sse
var _text_skip_object = []byte{
// .p2align 4, 0x00
// LCPI0_0
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // .quad 1
0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000008 .quad 6
//0x00000010 LCPI0_1
0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, //0x00000010 QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""'
//0x00000020 LCPI0_2
0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, //0x00000020 QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
//0x00000030 LCPI0_3
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, //0x00000030 QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' '
//0x00000040 LCPI0_4
0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, //0x00000040 QUAD $0x7b7b7b7b7b7b7b7b; QUAD $0x7b7b7b7b7b7b7b7b // .space 16, '{{{{{{{{{{{{{{{{'
//0x00000050 LCPI0_5
0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, //0x00000050 QUAD $0x7d7d7d7d7d7d7d7d; QUAD $0x7d7d7d7d7d7d7d7d // .space 16, '}}}}}}}}}}}}}}}}'
//0x00000060 LCPI0_6
0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, //0x00000060 QUAD $0x5b5b5b5b5b5b5b5b; QUAD $0x5b5b5b5b5b5b5b5b // .space 16, '[[[[[[[[[[[[[[[['
//0x00000070 LCPI0_7
0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, //0x00000070 QUAD $0x5d5d5d5d5d5d5d5d; QUAD $0x5d5d5d5d5d5d5d5d // .space 16, ']]]]]]]]]]]]]]]]'
//0x00000080 LCPI0_8
0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, //0x00000080 QUAD $0x2c2c2c2c2c2c2c2c; QUAD $0x2c2c2c2c2c2c2c2c // .space 16, ',,,,,,,,,,,,,,,,'
//0x00000090 LCPI0_9
0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, //0x00000090 QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf'
//0x000000a0 LCPI0_10
0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, //0x000000a0 QUAD $0x2f2f2f2f2f2f2f2f; QUAD $0x2f2f2f2f2f2f2f2f // .space 16, '////////////////'
//0x000000b0 LCPI0_11
0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, //0x000000b0 QUAD $0x3a3a3a3a3a3a3a3a; QUAD $0x3a3a3a3a3a3a3a3a // .space 16, '::::::::::::::::'
//0x000000c0 LCPI0_12
0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, //0x000000c0 QUAD $0x2b2b2b2b2b2b2b2b; QUAD $0x2b2b2b2b2b2b2b2b // .space 16, '++++++++++++++++'
//0x000000d0 LCPI0_13
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, //0x000000d0 QUAD $0x2d2d2d2d2d2d2d2d; QUAD $0x2d2d2d2d2d2d2d2d // .space 16, '----------------'
//0x000000e0 LCPI0_14
0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, //0x000000e0 QUAD $0x2e2e2e2e2e2e2e2e; QUAD $0x2e2e2e2e2e2e2e2e // .space 16, '................'
//0x000000f0 LCPI0_15
0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, //0x000000f0 QUAD $0x4545454545454545; QUAD $0x4545454545454545 // .space 16, 'EEEEEEEEEEEEEEEE'
//0x00000100 .p2align 4, 0x90
//0x00000100 _skip_object
0x55, //0x00000100 pushq %rbp
0x48, 0x89, 0xe5, //0x00000101 movq %rsp, %rbp
0x41, 0x57, //0x00000104 pushq %r15
0x41, 0x56, //0x00000106 pushq %r14
0x41, 0x55, //0x00000108 pushq %r13
0x41, 0x54, //0x0000010a pushq %r12
0x53, //0x0000010c pushq %rbx
0x48, 0x81, 0xec, 0x88, 0x00, 0x00, 0x00, //0x0000010d subq $136, %rsp
0x48, 0x89, 0x4d, 0x98, //0x00000114 movq %rcx, $-104(%rbp)
0x49, 0x89, 0xd5, //0x00000118 movq %rdx, %r13
0x49, 0x89, 0xf6, //0x0000011b movq %rsi, %r14
0x48, 0x89, 0x7d, 0xa8, //0x0000011e movq %rdi, $-88(%rbp)
0x0f, 0x10, 0x05, 0xd7, 0xfe, 0xff, 0xff, //0x00000122 movups $-297(%rip), %xmm0 /* LCPI0_0+0(%rip) */
0x0f, 0x11, 0x02, //0x00000129 movups %xmm0, (%rdx)
0x48, 0xc7, 0xc1, 0xff, 0xff, 0xff, 0xff, //0x0000012c movq $-1, %rcx
0x49, 0xbb, 0x00, 0x26, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, //0x00000133 movabsq $4294977024, %r11
0xf3, 0x0f, 0x6f, 0x05, 0xcb, 0xfe, 0xff, 0xff, //0x0000013d movdqu $-309(%rip), %xmm0 /* LCPI0_1+0(%rip) */
0xf3, 0x0f, 0x6f, 0x0d, 0xd3, 0xfe, 0xff, 0xff, //0x00000145 movdqu $-301(%rip), %xmm1 /* LCPI0_2+0(%rip) */
0xf3, 0x44, 0x0f, 0x6f, 0x25, 0xda, 0xfe, 0xff, 0xff, //0x0000014d movdqu $-294(%rip), %xmm12 /* LCPI0_3+0(%rip) */
0x66, 0x45, 0x0f, 0x76, 0xd2, //0x00000156 pcmpeqd %xmm10, %xmm10
0xf3, 0x44, 0x0f, 0x6f, 0x3d, 0x4c, 0xff, 0xff, 0xff, //0x0000015b movdqu $-180(%rip), %xmm15 /* LCPI0_11+0(%rip) */
0xf3, 0x44, 0x0f, 0x6f, 0x0d, 0x23, 0xff, 0xff, 0xff, //0x00000164 movdqu $-221(%rip), %xmm9 /* LCPI0_9+0(%rip) */
0xf3, 0x44, 0x0f, 0x6f, 0x1d, 0x7a, 0xff, 0xff, 0xff, //0x0000016d movdqu $-134(%rip), %xmm11 /* LCPI0_15+0(%rip) */
0xf3, 0x44, 0x0f, 0x6f, 0x35, 0x01, 0xff, 0xff, 0xff, //0x00000176 movdqu $-255(%rip), %xmm14 /* LCPI0_8+0(%rip) */
0xf3, 0x0f, 0x6f, 0x15, 0xe9, 0xfe, 0xff, 0xff, //0x0000017f movdqu $-279(%rip), %xmm2 /* LCPI0_7+0(%rip) */
0xf3, 0x44, 0x0f, 0x6f, 0x2d, 0xb0, 0xfe, 0xff, 0xff, //0x00000187 movdqu $-336(%rip), %xmm13 /* LCPI0_4+0(%rip) */
0xf3, 0x44, 0x0f, 0x6f, 0x05, 0xb7, 0xfe, 0xff, 0xff, //0x00000190 movdqu $-329(%rip), %xmm8 /* LCPI0_5+0(%rip) */
0x48, 0x89, 0x75, 0xd0, //0x00000199 movq %rsi, $-48(%rbp)
0x48, 0x89, 0x55, 0xb8, //0x0000019d movq %rdx, $-72(%rbp)
0xe9, 0x7a, 0x00, 0x00, 0x00, //0x000001a1 jmp LBB0_6
//0x000001a6 LBB0_613
0x66, 0x0f, 0xbc, 0xc2, //0x000001a6 bsfw %dx, %ax
0x0f, 0xb7, 0xc0, //0x000001aa movzwl %ax, %eax
0x48, 0x29, 0xc8, //0x000001ad subq %rcx, %rax
0x49, 0x89, 0x06, //0x000001b0 movq %rax, (%r14)
0x48, 0x85, 0xf6, //0x000001b3 testq %rsi, %rsi
0x0f, 0x8e, 0x9d, 0x38, 0x00, 0x00, //0x000001b6 jle LBB0_614
0x90, 0x90, 0x90, 0x90, //0x000001bc .p2align 4, 0x90
//0x000001c0 LBB0_4
0x4d, 0x8b, 0x45, 0x00, //0x000001c0 movq (%r13), %r8
0x48, 0x8b, 0x75, 0x90, //0x000001c4 movq $-112(%rbp), %rsi
0x48, 0x89, 0xf1, //0x000001c8 movq %rsi, %rcx
0x48, 0x89, 0xf0, //0x000001cb movq %rsi, %rax
0x4d, 0x85, 0xc0, //0x000001ce testq %r8, %r8
0x0f, 0x85, 0x49, 0x00, 0x00, 0x00, //0x000001d1 jne LBB0_6
0xe9, 0x6b, 0x38, 0x00, 0x00, //0x000001d7 jmp LBB0_638
//0x000001dc LBB0_1
0x49, 0xf7, 0xdb, //0x000001dc negq %r11
0x4d, 0x89, 0xdd, //0x000001df movq %r11, %r13
//0x000001e2 LBB0_2
0x4d, 0x85, 0xed, //0x000001e2 testq %r13, %r13
0x0f, 0x88, 0x47, 0x38, 0x00, 0x00, //0x000001e5 js LBB0_612
//0x000001eb LBB0_3
0x49, 0x01, 0xc5, //0x000001eb addq %rax, %r13
0x4c, 0x8b, 0x75, 0xd0, //0x000001ee movq $-48(%rbp), %r14
0x4d, 0x89, 0x2e, //0x000001f2 movq %r13, (%r14)
0x48, 0x85, 0xc0, //0x000001f5 testq %rax, %rax
0x4c, 0x8b, 0x6d, 0xb8, //0x000001f8 movq $-72(%rbp), %r13
0x49, 0xbb, 0x00, 0x26, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, //0x000001fc movabsq $4294977024, %r11
0x0f, 0x89, 0xb4, 0xff, 0xff, 0xff, //0x00000206 jns LBB0_4
0xe9, 0x36, 0x38, 0x00, 0x00, //0x0000020c jmp LBB0_638
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000211 .p2align 4, 0x90
//0x00000220 LBB0_6
0x48, 0x8b, 0x45, 0xa8, //0x00000220 movq $-88(%rbp), %rax
0x4c, 0x8b, 0x20, //0x00000224 movq (%rax), %r12
0x48, 0x8b, 0x40, 0x08, //0x00000227 movq $8(%rax), %rax
0x49, 0x8b, 0x16, //0x0000022b movq (%r14), %rdx
0x48, 0x39, 0xc2, //0x0000022e cmpq %rax, %rdx
0x0f, 0x83, 0x39, 0x00, 0x00, 0x00, //0x00000231 jae LBB0_11
0x41, 0x8a, 0x1c, 0x14, //0x00000237 movb (%r12,%rdx), %bl
0x80, 0xfb, 0x0d, //0x0000023b cmpb $13, %bl
0x0f, 0x84, 0x2c, 0x00, 0x00, 0x00, //0x0000023e je LBB0_11
0x80, 0xfb, 0x20, //0x00000244 cmpb $32, %bl
0x0f, 0x84, 0x23, 0x00, 0x00, 0x00, //0x00000247 je LBB0_11
0x80, 0xc3, 0xf7, //0x0000024d addb $-9, %bl
0x80, 0xfb, 0x01, //0x00000250 cmpb $1, %bl
0x0f, 0x86, 0x17, 0x00, 0x00, 0x00, //0x00000253 jbe LBB0_11
0x48, 0x89, 0xd6, //0x00000259 movq %rdx, %rsi
0xe9, 0x07, 0x01, 0x00, 0x00, //0x0000025c jmp LBB0_32
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000261 .p2align 4, 0x90
//0x00000270 LBB0_11
0x48, 0x8d, 0x72, 0x01, //0x00000270 leaq $1(%rdx), %rsi
0x48, 0x39, 0xc6, //0x00000274 cmpq %rax, %rsi
0x0f, 0x83, 0x23, 0x00, 0x00, 0x00, //0x00000277 jae LBB0_15
0x41, 0x8a, 0x1c, 0x34, //0x0000027d movb (%r12,%rsi), %bl
0x80, 0xfb, 0x0d, //0x00000281 cmpb $13, %bl
0x0f, 0x84, 0x16, 0x00, 0x00, 0x00, //0x00000284 je LBB0_15
0x80, 0xfb, 0x20, //0x0000028a cmpb $32, %bl
0x0f, 0x84, 0x0d, 0x00, 0x00, 0x00, //0x0000028d je LBB0_15
0x80, 0xc3, 0xf7, //0x00000293 addb $-9, %bl
0x80, 0xfb, 0x01, //0x00000296 cmpb $1, %bl
0x0f, 0x87, 0xc9, 0x00, 0x00, 0x00, //0x00000299 ja LBB0_32
0x90, //0x0000029f .p2align 4, 0x90
//0x000002a0 LBB0_15
0x48, 0x8d, 0x72, 0x02, //0x000002a0 leaq $2(%rdx), %rsi
0x48, 0x39, 0xc6, //0x000002a4 cmpq %rax, %rsi
0x0f, 0x83, 0x23, 0x00, 0x00, 0x00, //0x000002a7 jae LBB0_19
0x41, 0x8a, 0x1c, 0x34, //0x000002ad movb (%r12,%rsi), %bl
0x80, 0xfb, 0x0d, //0x000002b1 cmpb $13, %bl
0x0f, 0x84, 0x16, 0x00, 0x00, 0x00, //0x000002b4 je LBB0_19
0x80, 0xfb, 0x20, //0x000002ba cmpb $32, %bl
0x0f, 0x84, 0x0d, 0x00, 0x00, 0x00, //0x000002bd je LBB0_19
0x80, 0xc3, 0xf7, //0x000002c3 addb $-9, %bl
0x80, 0xfb, 0x01, //0x000002c6 cmpb $1, %bl
0x0f, 0x87, 0x99, 0x00, 0x00, 0x00, //0x000002c9 ja LBB0_32
0x90, //0x000002cf .p2align 4, 0x90
//0x000002d0 LBB0_19
0x48, 0x8d, 0x72, 0x03, //0x000002d0 leaq $3(%rdx), %rsi
0x48, 0x39, 0xc6, //0x000002d4 cmpq %rax, %rsi
0x0f, 0x83, 0x23, 0x00, 0x00, 0x00, //0x000002d7 jae LBB0_23
0x41, 0x8a, 0x1c, 0x34, //0x000002dd movb (%r12,%rsi), %bl
0x80, 0xfb, 0x0d, //0x000002e1 cmpb $13, %bl
0x0f, 0x84, 0x16, 0x00, 0x00, 0x00, //0x000002e4 je LBB0_23
0x80, 0xfb, 0x20, //0x000002ea cmpb $32, %bl
0x0f, 0x84, 0x0d, 0x00, 0x00, 0x00, //0x000002ed je LBB0_23
0x80, 0xc3, 0xf7, //0x000002f3 addb $-9, %bl
0x80, 0xfb, 0x01, //0x000002f6 cmpb $1, %bl
0x0f, 0x87, 0x69, 0x00, 0x00, 0x00, //0x000002f9 ja LBB0_32
0x90, //0x000002ff .p2align 4, 0x90
//0x00000300 LBB0_23
0x48, 0x83, 0xc2, 0x04, //0x00000300 addq $4, %rdx
0x48, 0x39, 0xd0, //0x00000304 cmpq %rdx, %rax
0x0f, 0x86, 0xd0, 0x36, 0x00, 0x00, //0x00000307 jbe LBB0_603
0x48, 0x39, 0xd0, //0x0000030d cmpq %rdx, %rax
0x0f, 0x84, 0x3a, 0x00, 0x00, 0x00, //0x00000310 je LBB0_29
0x49, 0x8d, 0x34, 0x04, //0x00000316 leaq (%r12,%rax), %rsi
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x0000031a .p2align 4, 0x90
//0x00000320 LBB0_26
0x41, 0x0f, 0xbe, 0x3c, 0x14, //0x00000320 movsbl (%r12,%rdx), %edi
0x83, 0xff, 0x20, //0x00000325 cmpl $32, %edi
0x0f, 0x87, 0x2e, 0x00, 0x00, 0x00, //0x00000328 ja LBB0_31
0x49, 0x0f, 0xa3, 0xfb, //0x0000032e btq %rdi, %r11
0x0f, 0x83, 0x24, 0x00, 0x00, 0x00, //0x00000332 jae LBB0_31
0x48, 0x83, 0xc2, 0x01, //0x00000338 addq $1, %rdx
0x48, 0x39, 0xd0, //0x0000033c cmpq %rdx, %rax
0x0f, 0x85, 0xdb, 0xff, 0xff, 0xff, //0x0000033f jne LBB0_26
0xe9, 0x0c, 0x00, 0x00, 0x00, //0x00000345 jmp LBB0_30
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x0000034a .p2align 4, 0x90
//0x00000350 LBB0_29
0x4c, 0x01, 0xe2, //0x00000350 addq %r12, %rdx
0x48, 0x89, 0xd6, //0x00000353 movq %rdx, %rsi
//0x00000356 LBB0_30
0x4c, 0x29, 0xe6, //0x00000356 subq %r12, %rsi
0x48, 0x89, 0xf2, //0x00000359 movq %rsi, %rdx
//0x0000035c LBB0_31
0x48, 0x89, 0xd6, //0x0000035c movq %rdx, %rsi
0x48, 0x39, 0xc2, //0x0000035f cmpq %rax, %rdx
0x0f, 0x83, 0x78, 0x36, 0x00, 0x00, //0x00000362 jae LBB0_604
//0x00000368 LBB0_32
0x48, 0x8d, 0x46, 0x01, //0x00000368 leaq $1(%rsi), %rax
0x49, 0x89, 0x06, //0x0000036c movq %rax, (%r14)
0x41, 0x0f, 0xbe, 0x3c, 0x34, //0x0000036f movsbl (%r12,%rsi), %edi
0x48, 0xc7, 0xc0, 0xff, 0xff, 0xff, 0xff, //0x00000374 movq $-1, %rax
0x85, 0xff, //0x0000037b testl %edi, %edi
0x0f, 0x84, 0xc4, 0x36, 0x00, 0x00, //0x0000037d je LBB0_638
0x4d, 0x8b, 0x4d, 0x00, //0x00000383 movq (%r13), %r9
0x4d, 0x8d, 0x41, 0xff, //0x00000387 leaq $-1(%r9), %r8
0x43, 0x8b, 0x5c, 0xcd, 0x00, //0x0000038b movl (%r13,%r9,8), %ebx
0x48, 0x83, 0xf9, 0xff, //0x00000390 cmpq $-1, %rcx
0x48, 0x0f, 0x45, 0xf1, //0x00000394 cmovneq %rcx, %rsi
0x83, 0xc3, 0xff, //0x00000398 addl $-1, %ebx
0x83, 0xfb, 0x05, //0x0000039b cmpl $5, %ebx
0x0f, 0x87, 0x82, 0x02, 0x00, 0x00, //0x0000039e ja LBB0_78
0x48, 0x8d, 0x15, 0x35, 0x39, 0x00, 0x00, //0x000003a4 leaq $14645(%rip), %rdx /* LJTI0_0+0(%rip) */
0x48, 0x63, 0x0c, 0x9a, //0x000003ab movslq (%rdx,%rbx,4), %rcx
0x48, 0x01, 0xd1, //0x000003af addq %rdx, %rcx
0xff, 0xe1, //0x000003b2 jmpq *%rcx
//0x000003b4 LBB0_35
0x83, 0xff, 0x2c, //0x000003b4 cmpl $44, %edi
0x0f, 0x84, 0xec, 0x04, 0x00, 0x00, //0x000003b7 je LBB0_117
0x83, 0xff, 0x5d, //0x000003bd cmpl $93, %edi
0x0f, 0x84, 0x48, 0x02, 0x00, 0x00, //0x000003c0 je LBB0_37
0xe9, 0x75, 0x36, 0x00, 0x00, //0x000003c6 jmp LBB0_637
//0x000003cb LBB0_38
0x40, 0x80, 0xff, 0x5d, //0x000003cb cmpb $93, %dil
0x0f, 0x84, 0x39, 0x02, 0x00, 0x00, //0x000003cf je LBB0_37
0x48, 0x89, 0x75, 0x90, //0x000003d5 movq %rsi, $-112(%rbp)
0x4b, 0xc7, 0x44, 0xcd, 0x00, 0x01, 0x00, 0x00, 0x00, //0x000003d9 movq $1, (%r13,%r9,8)
0x83, 0xff, 0x7b, //0x000003e2 cmpl $123, %edi
0x0f, 0x86, 0x4c, 0x02, 0x00, 0x00, //0x000003e5 jbe LBB0_79
0xe9, 0x50, 0x36, 0x00, 0x00, //0x000003eb jmp LBB0_637
//0x000003f0 LBB0_40
0x40, 0x80, 0xff, 0x22, //0x000003f0 cmpb $34, %dil
0x0f, 0x85, 0x46, 0x36, 0x00, 0x00, //0x000003f4 jne LBB0_637
0x4b, 0xc7, 0x44, 0xcd, 0x00, 0x04, 0x00, 0x00, 0x00, //0x000003fa movq $4, (%r13,%r9,8)
0x48, 0x8b, 0x4d, 0x98, //0x00000403 movq $-104(%rbp), %rcx
0xf6, 0xc1, 0x40, //0x00000407 testb $64, %cl
0x48, 0x89, 0x75, 0x90, //0x0000040a movq %rsi, $-112(%rbp)
0x0f, 0x85, 0x7c, 0x06, 0x00, 0x00, //0x0000040e jne LBB0_125
0x49, 0x8b, 0x16, //0x00000414 movq (%r14), %rdx
0x48, 0x8b, 0x45, 0xa8, //0x00000417 movq $-88(%rbp), %rax
0x48, 0x8b, 0x40, 0x08, //0x0000041b movq $8(%rax), %rax
0xf6, 0xc1, 0x20, //0x0000041f testb $32, %cl
0x48, 0x89, 0x45, 0xa0, //0x00000422 movq %rax, $-96(%rbp)
0x48, 0x89, 0x55, 0xb0, //0x00000426 movq %rdx, $-80(%rbp)
0x0f, 0x85, 0x5e, 0x09, 0x00, 0x00, //0x0000042a jne LBB0_157
0x49, 0x89, 0xc1, //0x00000430 movq %rax, %r9
0x49, 0x29, 0xd1, //0x00000433 subq %rdx, %r9
0x0f, 0x84, 0xc2, 0x37, 0x00, 0x00, //0x00000436 je LBB0_642
0x49, 0x83, 0xf9, 0x40, //0x0000043c cmpq $64, %r9
0x0f, 0x82, 0x4a, 0x2a, 0x00, 0x00, //0x00000440 jb LBB0_484
0x48, 0x8b, 0x45, 0xb0, //0x00000446 movq $-80(%rbp), %rax
0x49, 0x89, 0xc6, //0x0000044a movq %rax, %r14
0x49, 0xf7, 0xd6, //0x0000044d notq %r14
0x48, 0xc7, 0x45, 0xc8, 0xff, 0xff, 0xff, 0xff, //0x00000450 movq $-1, $-56(%rbp)
0x45, 0x31, 0xc0, //0x00000458 xorl %r8d, %r8d
0x90, 0x90, 0x90, 0x90, 0x90, //0x0000045b .p2align 4, 0x90
//0x00000460 LBB0_46
0xf3, 0x41, 0x0f, 0x6f, 0x1c, 0x04, //0x00000460 movdqu (%r12,%rax), %xmm3
0xf3, 0x41, 0x0f, 0x6f, 0x64, 0x04, 0x10, //0x00000466 movdqu $16(%r12,%rax), %xmm4
0xf3, 0x41, 0x0f, 0x6f, 0x6c, 0x04, 0x20, //0x0000046d movdqu $32(%r12,%rax), %xmm5
0xf3, 0x41, 0x0f, 0x6f, 0x74, 0x04, 0x30, //0x00000474 movdqu $48(%r12,%rax), %xmm6
0x66, 0x0f, 0x6f, 0xfb, //0x0000047b movdqa %xmm3, %xmm7
0x66, 0x0f, 0x74, 0xf8, //0x0000047f pcmpeqb %xmm0, %xmm7
0x66, 0x44, 0x0f, 0xd7, 0xd7, //0x00000483 pmovmskb %xmm7, %r10d
0x66, 0x0f, 0x6f, 0xfc, //0x00000488 movdqa %xmm4, %xmm7
0x66, 0x0f, 0x74, 0xf8, //0x0000048c pcmpeqb %xmm0, %xmm7
0x66, 0x0f, 0xd7, 0xdf, //0x00000490 pmovmskb %xmm7, %ebx
0x66, 0x0f, 0x6f, 0xfd, //0x00000494 movdqa %xmm5, %xmm7
0x66, 0x0f, 0x74, 0xf8, //0x00000498 pcmpeqb %xmm0, %xmm7
0x66, 0x0f, 0xd7, 0xff, //0x0000049c pmovmskb %xmm7, %edi
0x66, 0x0f, 0x6f, 0xfe, //0x000004a0 movdqa %xmm6, %xmm7
0x66, 0x0f, 0x74, 0xf8, //0x000004a4 pcmpeqb %xmm0, %xmm7
0x66, 0x0f, 0xd7, 0xd7, //0x000004a8 pmovmskb %xmm7, %edx
0x66, 0x0f, 0x74, 0xd9, //0x000004ac pcmpeqb %xmm1, %xmm3
0x66, 0x44, 0x0f, 0xd7, 0xdb, //0x000004b0 pmovmskb %xmm3, %r11d
0x66, 0x0f, 0x74, 0xe1, //0x000004b5 pcmpeqb %xmm1, %xmm4
0x66, 0x0f, 0xd7, 0xcc, //0x000004b9 pmovmskb %xmm4, %ecx
0x66, 0x0f, 0x74, 0xe9, //0x000004bd pcmpeqb %xmm1, %xmm5
0x66, 0x0f, 0xd7, 0xf5, //0x000004c1 pmovmskb %xmm5, %esi
0x66, 0x0f, 0x74, 0xf1, //0x000004c5 pcmpeqb %xmm1, %xmm6
0x66, 0x44, 0x0f, 0xd7, 0xfe, //0x000004c9 pmovmskb %xmm6, %r15d
0x48, 0xc1, 0xe2, 0x30, //0x000004ce shlq $48, %rdx
0x48, 0xc1, 0xe7, 0x20, //0x000004d2 shlq $32, %rdi
0x48, 0x09, 0xd7, //0x000004d6 orq %rdx, %rdi
0x48, 0xc1, 0xe3, 0x10, //0x000004d9 shlq $16, %rbx
0x48, 0x09, 0xfb, //0x000004dd orq %rdi, %rbx
0x49, 0x09, 0xda, //0x000004e0 orq %rbx, %r10
0x49, 0xc1, 0xe7, 0x30, //0x000004e3 shlq $48, %r15
0x48, 0xc1, 0xe6, 0x20, //0x000004e7 shlq $32, %rsi
0x4c, 0x09, 0xfe, //0x000004eb orq %r15, %rsi
0x48, 0xc1, 0xe1, 0x10, //0x000004ee shlq $16, %rcx
0x48, 0x09, 0xf1, //0x000004f2 orq %rsi, %rcx
0x49, 0x09, 0xcb, //0x000004f5 orq %rcx, %r11
0x0f, 0x85, 0x30, 0x00, 0x00, 0x00, //0x000004f8 jne LBB0_55
0x4d, 0x85, 0xc0, //0x000004fe testq %r8, %r8
0x0f, 0x85, 0x3d, 0x00, 0x00, 0x00, //0x00000501 jne LBB0_57
0x45, 0x31, 0xc0, //0x00000507 xorl %r8d, %r8d
0x4d, 0x85, 0xd2, //0x0000050a testq %r10, %r10
0x0f, 0x85, 0x83, 0x00, 0x00, 0x00, //0x0000050d jne LBB0_58
//0x00000513 LBB0_49
0x49, 0x83, 0xc1, 0xc0, //0x00000513 addq $-64, %r9
0x49, 0x83, 0xc6, 0xc0, //0x00000517 addq $-64, %r14
0x48, 0x83, 0xc0, 0x40, //0x0000051b addq $64, %rax
0x49, 0x83, 0xf9, 0x3f, //0x0000051f cmpq $63, %r9
0x0f, 0x87, 0x37, 0xff, 0xff, 0xff, //0x00000523 ja LBB0_46
0xe9, 0xce, 0x21, 0x00, 0x00, //0x00000529 jmp LBB0_50
//0x0000052e LBB0_55
0x48, 0x83, 0x7d, 0xc8, 0xff, //0x0000052e cmpq $-1, $-56(%rbp)
0x0f, 0x85, 0x0b, 0x00, 0x00, 0x00, //0x00000533 jne LBB0_57
0x49, 0x0f, 0xbc, 0xcb, //0x00000539 bsfq %r11, %rcx
0x48, 0x01, 0xc1, //0x0000053d addq %rax, %rcx
0x48, 0x89, 0x4d, 0xc8, //0x00000540 movq %rcx, $-56(%rbp)
//0x00000544 LBB0_57
0x4c, 0x89, 0xc1, //0x00000544 movq %r8, %rcx
0x48, 0xf7, 0xd1, //0x00000547 notq %rcx
0x4c, 0x21, 0xd9, //0x0000054a andq %r11, %rcx
0x48, 0x8d, 0x14, 0x09, //0x0000054d leaq (%rcx,%rcx), %rdx
0x4c, 0x09, 0xc2, //0x00000551 orq %r8, %rdx
0x48, 0x89, 0xd6, //0x00000554 movq %rdx, %rsi
0x48, 0xf7, 0xd6, //0x00000557 notq %rsi
0x4c, 0x21, 0xde, //0x0000055a andq %r11, %rsi
0x48, 0xbf, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, //0x0000055d movabsq $-6148914691236517206, %rdi
0x48, 0x21, 0xfe, //0x00000567 andq %rdi, %rsi
0x45, 0x31, 0xc0, //0x0000056a xorl %r8d, %r8d
0x48, 0x01, 0xce, //0x0000056d addq %rcx, %rsi
0x41, 0x0f, 0x92, 0xc0, //0x00000570 setb %r8b
0x48, 0x01, 0xf6, //0x00000574 addq %rsi, %rsi
0x48, 0xb9, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, //0x00000577 movabsq $6148914691236517205, %rcx
0x48, 0x31, 0xce, //0x00000581 xorq %rcx, %rsi
0x48, 0x21, 0xd6, //0x00000584 andq %rdx, %rsi
0x48, 0xf7, 0xd6, //0x00000587 notq %rsi
0x49, 0x21, 0xf2, //0x0000058a andq %rsi, %r10
0x4d, 0x85, 0xd2, //0x0000058d testq %r10, %r10
0x0f, 0x84, 0x7d, 0xff, 0xff, 0xff, //0x00000590 je LBB0_49
//0x00000596 LBB0_58
0x49, 0x0f, 0xbc, 0xc2, //0x00000596 bsfq %r10, %rax
0x4c, 0x29, 0xf0, //0x0000059a subq %r14, %rax
0x4c, 0x8b, 0x75, 0xd0, //0x0000059d movq $-48(%rbp), %r14
0x49, 0xbb, 0x00, 0x26, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, //0x000005a1 movabsq $4294977024, %r11
0xe9, 0xd6, 0x0c, 0x00, 0x00, //0x000005ab jmp LBB0_223
//0x000005b0 LBB0_59
0x40, 0x80, 0xff, 0x3a, //0x000005b0 cmpb $58, %dil
0x0f, 0x85, 0x86, 0x34, 0x00, 0x00, //0x000005b4 jne LBB0_637
0x48, 0x89, 0x75, 0x90, //0x000005ba movq %rsi, $-112(%rbp)
0x4b, 0xc7, 0x44, 0xcd, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000005be movq $0, (%r13,%r9,8)
0xe9, 0xf4, 0xfb, 0xff, 0xff, //0x000005c7 jmp LBB0_4
//0x000005cc LBB0_61
0x83, 0xff, 0x2c, //0x000005cc cmpl $44, %edi
0x0f, 0x85, 0x30, 0x00, 0x00, 0x00, //0x000005cf jne LBB0_62
0x49, 0x81, 0xf9, 0xff, 0x0f, 0x00, 0x00, //0x000005d5 cmpq $4095, %r9
0x0f, 0x8f, 0x0a, 0x34, 0x00, 0x00, //0x000005dc jg LBB0_634
0x48, 0x89, 0x75, 0x90, //0x000005e2 movq %rsi, $-112(%rbp)
0x49, 0x8d, 0x41, 0x01, //0x000005e6 leaq $1(%r9), %rax
0x49, 0x89, 0x45, 0x00, //0x000005ea movq %rax, (%r13)
0x4b, 0xc7, 0x44, 0xcd, 0x08, 0x03, 0x00, 0x00, 0x00, //0x000005ee movq $3, $8(%r13,%r9,8)
0xe9, 0xc4, 0xfb, 0xff, 0xff, //0x000005f7 jmp LBB0_4
//0x000005fc LBB0_63
0x83, 0xff, 0x22, //0x000005fc cmpl $34, %edi
0x0f, 0x84, 0xcb, 0x02, 0x00, 0x00, //0x000005ff je LBB0_64
//0x00000605 LBB0_62
0x83, 0xff, 0x7d, //0x00000605 cmpl $125, %edi
0x0f, 0x85, 0x32, 0x34, 0x00, 0x00, //0x00000608 jne LBB0_637
//0x0000060e LBB0_37
0x4d, 0x89, 0x45, 0x00, //0x0000060e movq %r8, (%r13)
0x48, 0x89, 0xf1, //0x00000612 movq %rsi, %rcx
0x48, 0x89, 0xf0, //0x00000615 movq %rsi, %rax
0x4d, 0x85, 0xc0, //0x00000618 testq %r8, %r8
0x0f, 0x85, 0xff, 0xfb, 0xff, 0xff, //0x0000061b jne LBB0_6
0xe9, 0x21, 0x34, 0x00, 0x00, //0x00000621 jmp LBB0_638
//0x00000626 LBB0_78
0x48, 0x89, 0x75, 0x90, //0x00000626 movq %rsi, $-112(%rbp)
0x4d, 0x89, 0x45, 0x00, //0x0000062a movq %r8, (%r13)
0x83, 0xff, 0x7b, //0x0000062e cmpl $123, %edi
0x0f, 0x87, 0x09, 0x34, 0x00, 0x00, //0x00000631 ja LBB0_637
//0x00000637 LBB0_79
0x89, 0xf9, //0x00000637 movl %edi, %ecx
0x48, 0x8d, 0x15, 0xb8, 0x36, 0x00, 0x00, //0x00000639 leaq $14008(%rip), %rdx /* LJTI0_1+0(%rip) */
0x48, 0x63, 0x0c, 0x8a, //0x00000640 movslq (%rdx,%rcx,4), %rcx
0x48, 0x01, 0xd1, //0x00000644 addq %rdx, %rcx
0xff, 0xe1, //0x00000647 jmpq *%rcx
//0x00000649 LBB0_80
0x48, 0x8b, 0x45, 0xa8, //0x00000649 movq $-88(%rbp), %rax
0x48, 0x8b, 0x78, 0x08, //0x0000064d movq $8(%rax), %rdi
0x49, 0x8b, 0x36, //0x00000651 movq (%r14), %rsi
0xf6, 0x45, 0x98, 0x40, //0x00000654 testb $64, $-104(%rbp)
0x0f, 0x85, 0x40, 0x05, 0x00, 0x00, //0x00000658 jne LBB0_135
0x48, 0x8d, 0x46, 0xff, //0x0000065e leaq $-1(%rsi), %rax
0x48, 0x29, 0xc7, //0x00000662 subq %rax, %rdi
0x0f, 0x84, 0xc0, 0x33, 0x00, 0x00, //0x00000665 je LBB0_611
0x4d, 0x8d, 0x34, 0x34, //0x0000066b leaq (%r12,%rsi), %r14
0x49, 0x83, 0xc6, 0xff, //0x0000066f addq $-1, %r14
0x41, 0x80, 0x3e, 0x30, //0x00000673 cmpb $48, (%r14)
0x0f, 0x85, 0x37, 0x00, 0x00, 0x00, //0x00000677 jne LBB0_86
0x41, 0xbd, 0x01, 0x00, 0x00, 0x00, //0x0000067d movl $1, %r13d
0x48, 0x83, 0xff, 0x01, //0x00000683 cmpq $1, %rdi
0x0f, 0x84, 0x5e, 0xfb, 0xff, 0xff, //0x00000687 je LBB0_3
0x41, 0x8a, 0x0c, 0x34, //0x0000068d movb (%r12,%rsi), %cl
0x80, 0xc1, 0xd2, //0x00000691 addb $-46, %cl
0x80, 0xf9, 0x37, //0x00000694 cmpb $55, %cl
0x0f, 0x87, 0x4e, 0xfb, 0xff, 0xff, //0x00000697 ja LBB0_3
0x0f, 0xb6, 0xc9, //0x0000069d movzbl %cl, %ecx
0x48, 0xba, 0x01, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, //0x000006a0 movabsq $36028797027352577, %rdx
0x48, 0x0f, 0xa3, 0xca, //0x000006aa btq %rcx, %rdx
0x0f, 0x83, 0x37, 0xfb, 0xff, 0xff, //0x000006ae jae LBB0_3
//0x000006b4 LBB0_86
0x48, 0x89, 0x75, 0xc0, //0x000006b4 movq %rsi, $-64(%rbp)
0x48, 0x83, 0xff, 0x10, //0x000006b8 cmpq $16, %rdi
0x0f, 0x82, 0x14, 0x27, 0x00, 0x00, //0x000006bc jb LBB0_472
0x49, 0xc7, 0xc1, 0xff, 0xff, 0xff, 0xff, //0x000006c2 movq $-1, %r9
0x45, 0x31, 0xed, //0x000006c9 xorl %r13d, %r13d
0x49, 0xc7, 0xc7, 0xff, 0xff, 0xff, 0xff, //0x000006cc movq $-1, %r15
0x49, 0xc7, 0xc0, 0xff, 0xff, 0xff, 0xff, //0x000006d3 movq $-1, %r8
0x49, 0x89, 0xfa, //0x000006da movq %rdi, %r10
0x90, 0x90, 0x90, //0x000006dd .p2align 4, 0x90
//0x000006e0 LBB0_88
0xf3, 0x43, 0x0f, 0x6f, 0x1c, 0x2e, //0x000006e0 movdqu (%r14,%r13), %xmm3
0x66, 0x0f, 0x6f, 0xe3, //0x000006e6 movdqa %xmm3, %xmm4
0x66, 0x0f, 0x64, 0x25, 0xae, 0xf9, 0xff, 0xff, //0x000006ea pcmpgtb $-1618(%rip), %xmm4 /* LCPI0_10+0(%rip) */
0x66, 0x41, 0x0f, 0x6f, 0xef, //0x000006f2 movdqa %xmm15, %xmm5
0x66, 0x0f, 0x64, 0xeb, //0x000006f7 pcmpgtb %xmm3, %xmm5
0x66, 0x0f, 0xdb, 0xec, //0x000006fb pand %xmm4, %xmm5
0x66, 0x0f, 0x6f, 0xe3, //0x000006ff movdqa %xmm3, %xmm4
0x66, 0x0f, 0x74, 0x25, 0xb5, 0xf9, 0xff, 0xff, //0x00000703 pcmpeqb $-1611(%rip), %xmm4 /* LCPI0_12+0(%rip) */
0x66, 0x0f, 0x6f, 0xf3, //0x0000070b movdqa %xmm3, %xmm6
0x66, 0x0f, 0x74, 0x35, 0xb9, 0xf9, 0xff, 0xff, //0x0000070f pcmpeqb $-1607(%rip), %xmm6 /* LCPI0_13+0(%rip) */
0x66, 0x0f, 0xeb, 0xf4, //0x00000717 por %xmm4, %xmm6
0x66, 0x0f, 0x6f, 0xe3, //0x0000071b movdqa %xmm3, %xmm4
0x66, 0x41, 0x0f, 0xdb, 0xe1, //0x0000071f pand %xmm9, %xmm4
0x66, 0x0f, 0x74, 0x1d, 0xb4, 0xf9, 0xff, 0xff, //0x00000724 pcmpeqb $-1612(%rip), %xmm3 /* LCPI0_14+0(%rip) */
0x66, 0x41, 0x0f, 0x74, 0xe3, //0x0000072c pcmpeqb %xmm11, %xmm4
0x66, 0x0f, 0xd7, 0xd4, //0x00000731 pmovmskb %xmm4, %edx
0x66, 0x0f, 0xeb, 0xe3, //0x00000735 por %xmm3, %xmm4
0x66, 0x0f, 0xeb, 0xee, //0x00000739 por %xmm6, %xmm5
0x66, 0x0f, 0xeb, 0xec, //0x0000073d por %xmm4, %xmm5
0x66, 0x44, 0x0f, 0xd7, 0xdb, //0x00000741 pmovmskb %xmm3, %r11d
0x66, 0x0f, 0xd7, 0xf6, //0x00000746 pmovmskb %xmm6, %esi
0x66, 0x0f, 0xd7, 0xcd, //0x0000074a pmovmskb %xmm5, %ecx
0xf7, 0xd1, //0x0000074e notl %ecx
0x0f, 0xbc, 0xc9, //0x00000750 bsfl %ecx, %ecx
0x83, 0xf9, 0x10, //0x00000753 cmpl $16, %ecx
0x0f, 0x84, 0x12, 0x00, 0x00, 0x00, //0x00000756 je LBB0_90
0xbb, 0xff, 0xff, 0xff, 0xff, //0x0000075c movl $-1, %ebx
0xd3, 0xe3, //0x00000761 shll %cl, %ebx
0xf7, 0xd3, //0x00000763 notl %ebx
0x41, 0x21, 0xdb, //0x00000765 andl %ebx, %r11d
0x21, 0xda, //0x00000768 andl %ebx, %edx
0x21, 0xf3, //0x0000076a andl %esi, %ebx
0x89, 0xde, //0x0000076c movl %ebx, %esi
//0x0000076e LBB0_90
0x41, 0x8d, 0x5b, 0xff, //0x0000076e leal $-1(%r11), %ebx
0x44, 0x21, 0xdb, //0x00000772 andl %r11d, %ebx
0x0f, 0x85, 0x12, 0x1f, 0x00, 0x00, //0x00000775 jne LBB0_429
0x8d, 0x5a, 0xff, //0x0000077b leal $-1(%rdx), %ebx
0x21, 0xd3, //0x0000077e andl %edx, %ebx
0x0f, 0x85, 0x07, 0x1f, 0x00, 0x00, //0x00000780 jne LBB0_429
0x8d, 0x5e, 0xff, //0x00000786 leal $-1(%rsi), %ebx
0x21, 0xf3, //0x00000789 andl %esi, %ebx
0x0f, 0x85, 0xfc, 0x1e, 0x00, 0x00, //0x0000078b jne LBB0_429
0x45, 0x85, 0xdb, //0x00000791 testl %r11d, %r11d
0x0f, 0x84, 0x14, 0x00, 0x00, 0x00, //0x00000794 je LBB0_96
0x41, 0x0f, 0xbc, 0xdb, //0x0000079a bsfl %r11d, %ebx
0x49, 0x83, 0xf8, 0xff, //0x0000079e cmpq $-1, %r8
0x0f, 0x85, 0x75, 0x22, 0x00, 0x00, //0x000007a2 jne LBB0_436
0x4c, 0x01, 0xeb, //0x000007a8 addq %r13, %rbx
0x49, 0x89, 0xd8, //0x000007ab movq %rbx, %r8
//0x000007ae LBB0_96
0x85, 0xd2, //0x000007ae testl %edx, %edx
0x0f, 0x84, 0x13, 0x00, 0x00, 0x00, //0x000007b0 je LBB0_99
0x0f, 0xbc, 0xd2, //0x000007b6 bsfl %edx, %edx
0x49, 0x83, 0xff, 0xff, //0x000007b9 cmpq $-1, %r15
0x0f, 0x85, 0xd1, 0x20, 0x00, 0x00, //0x000007bd jne LBB0_435
0x4c, 0x01, 0xea, //0x000007c3 addq %r13, %rdx
0x49, 0x89, 0xd7, //0x000007c6 movq %rdx, %r15
//0x000007c9 LBB0_99
0x85, 0xf6, //0x000007c9 testl %esi, %esi
0x0f, 0x84, 0x13, 0x00, 0x00, 0x00, //0x000007cb je LBB0_102
0x0f, 0xbc, 0xd6, //0x000007d1 bsfl %esi, %edx
0x49, 0x83, 0xf9, 0xff, //0x000007d4 cmpq $-1, %r9
0x0f, 0x85, 0xb6, 0x20, 0x00, 0x00, //0x000007d8 jne LBB0_435
0x4c, 0x01, 0xea, //0x000007de addq %r13, %rdx
0x49, 0x89, 0xd1, //0x000007e1 movq %rdx, %r9
//0x000007e4 LBB0_102
0x83, 0xf9, 0x10, //0x000007e4 cmpl $16, %ecx
0x0f, 0x85, 0xbb, 0x07, 0x00, 0x00, //0x000007e7 jne LBB0_183
0x49, 0x83, 0xc2, 0xf0, //0x000007ed addq $-16, %r10
0x49, 0x83, 0xc5, 0x10, //0x000007f1 addq $16, %r13
0x49, 0x83, 0xfa, 0x0f, //0x000007f5 cmpq $15, %r10
0x0f, 0x87, 0xe1, 0xfe, 0xff, 0xff, //0x000007f9 ja LBB0_88
0x4b, 0x8d, 0x0c, 0x2e, //0x000007ff leaq (%r14,%r13), %rcx
0x49, 0x89, 0xcb, //0x00000803 movq %rcx, %r11
0x4c, 0x39, 0xef, //0x00000806 cmpq %r13, %rdi
0x0f, 0x84, 0xa2, 0x07, 0x00, 0x00, //0x00000809 je LBB0_184
//0x0000080f LBB0_105
0x4e, 0x8d, 0x1c, 0x11, //0x0000080f leaq (%rcx,%r10), %r11
0x48, 0x89, 0xca, //0x00000813 movq %rcx, %rdx
0x48, 0x2b, 0x55, 0xc0, //0x00000816 subq $-64(%rbp), %rdx
0x4c, 0x29, 0xe2, //0x0000081a subq %r12, %rdx
0x48, 0x83, 0xc2, 0x01, //0x0000081d addq $1, %rdx
0x31, 0xff, //0x00000821 xorl %edi, %edi
0x4c, 0x8d, 0x2d, 0x2a, 0x37, 0x00, 0x00, //0x00000823 leaq $14122(%rip), %r13 /* LJTI0_3+0(%rip) */
0xe9, 0x2e, 0x00, 0x00, 0x00, //0x0000082a jmp LBB0_110
//0x0000082f LBB0_106
0x83, 0xfe, 0x65, //0x0000082f cmpl $101, %esi
0x0f, 0x85, 0xbc, 0x09, 0x00, 0x00, //0x00000832 jne LBB0_212
//0x00000838 LBB0_107
0x49, 0x83, 0xff, 0xff, //0x00000838 cmpq $-1, %r15
0x0f, 0x85, 0x76, 0x1e, 0x00, 0x00, //0x0000083c jne LBB0_433
0x4c, 0x8d, 0x3c, 0x3a, //0x00000842 leaq (%rdx,%rdi), %r15
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000846 .p2align 4, 0x90
//0x00000850 LBB0_109
0x48, 0x83, 0xc7, 0x01, //0x00000850 addq $1, %rdi
0x49, 0x39, 0xfa, //0x00000854 cmpq %rdi, %r10
0x0f, 0x84, 0x54, 0x07, 0x00, 0x00, //0x00000857 je LBB0_184
//0x0000085d LBB0_110
0x0f, 0xbe, 0x34, 0x39, //0x0000085d movsbl (%rcx,%rdi), %esi
0x8d, 0x5e, 0xd0, //0x00000861 leal $-48(%rsi), %ebx
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | true |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/value_subr.go | vendor/github.com/bytedance/sonic/internal/native/sse/value_subr.go | // +build !noasm !appengine
// Code generated by asm2asm, DO NOT EDIT.
package sse
import (
`github.com/bytedance/sonic/loader`
)
const (
_entry__value = 208
)
const (
_stack__value = 128
)
const (
_size__value = 11788
)
var (
_pcsp__value = [][2]uint32{
{0x1, 0},
{0x6, 8},
{0x8, 16},
{0xa, 24},
{0xc, 32},
{0xd, 40},
{0x11, 48},
{0x20a, 128},
{0x20b, 48},
{0x20d, 40},
{0x20f, 32},
{0x211, 24},
{0x213, 16},
{0x214, 8},
{0x215, 0},
{0x2e0c, 128},
}
)
var _cfunc_value = []loader.CFunc{
{"_value_entry", 0, _entry__value, 0, nil},
{"_value", _entry__value, _size__value, _stack__value, _pcsp__value},
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/vnumber_text_amd64.go | vendor/github.com/bytedance/sonic/internal/native/sse/vnumber_text_amd64.go | // +build amd64
// Code generated by asm2asm, DO NOT EDIT.
package sse
var _text_vnumber = []byte{
// .p2align 4, 0x00
// LCPI0_0
0x00, 0x00, 0x30, 0x43, // .long 1127219200
0x00, 0x00, 0x30, 0x45, //0x00000004 .long 1160773632
0x00, 0x00, 0x00, 0x00, //0x00000008 .long 0
0x00, 0x00, 0x00, 0x00, //0x0000000c .long 0
//0x00000010 LCPI0_1
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x43, //0x00000010 .quad 0x4330000000000000
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x45, //0x00000018 .quad 0x4530000000000000
//0x00000020 .p2align 3, 0x00
//0x00000020 LCPI0_2
0x00, 0x00, 0x34, 0x26, 0xf5, 0x6b, 0x0c, 0x43, //0x00000020 .quad 0x430c6bf526340000
//0x00000028 LCPI0_3
0x00, 0x00, 0x34, 0x26, 0xf5, 0x6b, 0x0c, 0xc3, //0x00000028 .quad 0xc30c6bf526340000
//0x00000030 .p2align 4, 0x90
//0x00000030 _vnumber
0x55, //0x00000030 pushq %rbp
0x48, 0x89, 0xe5, //0x00000031 movq %rsp, %rbp
0x41, 0x57, //0x00000034 pushq %r15
0x41, 0x56, //0x00000036 pushq %r14
0x41, 0x55, //0x00000038 pushq %r13
0x41, 0x54, //0x0000003a pushq %r12
0x53, //0x0000003c pushq %rbx
0x48, 0x83, 0xec, 0x58, //0x0000003d subq $88, %rsp
0x49, 0x89, 0xd7, //0x00000041 movq %rdx, %r15
0x4c, 0x8b, 0x0f, //0x00000044 movq (%rdi), %r9
0x48, 0x8b, 0x57, 0x08, //0x00000047 movq $8(%rdi), %rdx
0x48, 0x8b, 0x0e, //0x0000004b movq (%rsi), %rcx
0x4d, 0x8b, 0x67, 0x20, //0x0000004e movq $32(%r15), %r12
0x4d, 0x8b, 0x6f, 0x28, //0x00000052 movq $40(%r15), %r13
0x49, 0xc7, 0x07, 0x09, 0x00, 0x00, 0x00, //0x00000056 movq $9, (%r15)
0x66, 0x0f, 0xef, 0xc0, //0x0000005d pxor %xmm0, %xmm0
0xf3, 0x41, 0x0f, 0x7f, 0x47, 0x08, //0x00000061 movdqu %xmm0, $8(%r15)
0x48, 0x8b, 0x06, //0x00000067 movq (%rsi), %rax
0x49, 0x89, 0x47, 0x18, //0x0000006a movq %rax, $24(%r15)
0x48, 0x39, 0xd1, //0x0000006e cmpq %rdx, %rcx
0x0f, 0x83, 0x21, 0x01, 0x00, 0x00, //0x00000071 jae LBB0_19
0x41, 0x8a, 0x1c, 0x09, //0x00000077 movb (%r9,%rcx), %bl
0x41, 0xb8, 0x01, 0x00, 0x00, 0x00, //0x0000007b movl $1, %r8d
0x80, 0xfb, 0x2d, //0x00000081 cmpb $45, %bl
0x49, 0x89, 0xd6, //0x00000084 movq %rdx, %r14
0x0f, 0x85, 0x1a, 0x01, 0x00, 0x00, //0x00000087 jne LBB0_20
0x48, 0x83, 0xc1, 0x01, //0x0000008d addq $1, %rcx
0x48, 0x39, 0xd1, //0x00000091 cmpq %rdx, %rcx
0x0f, 0x83, 0xfe, 0x00, 0x00, 0x00, //0x00000094 jae LBB0_19
0x45, 0x8a, 0x1c, 0x09, //0x0000009a movb (%r9,%rcx), %r11b
0x41, 0xb8, 0xff, 0xff, 0xff, 0xff, //0x0000009e movl $-1, %r8d
0x41, 0x8d, 0x43, 0xd0, //0x000000a4 leal $-48(%r11), %eax
0x3c, 0x0a, //0x000000a8 cmpb $10, %al
0x0f, 0x83, 0x06, 0x01, 0x00, 0x00, //0x000000aa jae LBB0_21
//0x000000b0 LBB0_4
0x48, 0x89, 0x75, 0xa8, //0x000000b0 movq %rsi, $-88(%rbp)
0x41, 0x80, 0xfb, 0x30, //0x000000b4 cmpb $48, %r11b
0x0f, 0x85, 0x34, 0x00, 0x00, 0x00, //0x000000b8 jne LBB0_8
0x48, 0x8d, 0x41, 0x01, //0x000000be leaq $1(%rcx), %rax
0x4c, 0x39, 0xf1, //0x000000c2 cmpq %r14, %rcx
0x0f, 0x83, 0x09, 0x01, 0x00, 0x00, //0x000000c5 jae LBB0_23
0x41, 0x8a, 0x14, 0x01, //0x000000cb movb (%r9,%rax), %dl
0x80, 0xc2, 0xd2, //0x000000cf addb $-46, %dl
0x80, 0xfa, 0x37, //0x000000d2 cmpb $55, %dl
0x0f, 0x87, 0xf9, 0x00, 0x00, 0x00, //0x000000d5 ja LBB0_23
0x0f, 0xb6, 0xd2, //0x000000db movzbl %dl, %edx
0x48, 0xbf, 0x01, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, //0x000000de movabsq $36028797027352577, %rdi
0x48, 0x0f, 0xa3, 0xd7, //0x000000e8 btq %rdx, %rdi
0x0f, 0x83, 0xe2, 0x00, 0x00, 0x00, //0x000000ec jae LBB0_23
//0x000000f2 LBB0_8
0x4c, 0x89, 0x45, 0xc8, //0x000000f2 movq %r8, $-56(%rbp)
0x88, 0x5d, 0xb8, //0x000000f6 movb %bl, $-72(%rbp)
0xb0, 0x01, //0x000000f9 movb $1, %al
0x89, 0x45, 0xc0, //0x000000fb movl %eax, $-64(%rbp)
0x4c, 0x39, 0xf1, //0x000000fe cmpq %r14, %rcx
0x0f, 0x83, 0xbe, 0x00, 0x00, 0x00, //0x00000101 jae LBB0_22
0x41, 0xba, 0xd0, 0xff, 0xff, 0xff, //0x00000107 movl $4294967248, %r10d
0x48, 0x83, 0xc1, 0x01, //0x0000010d addq $1, %rcx
0x31, 0xd2, //0x00000111 xorl %edx, %edx
0x31, 0xdb, //0x00000113 xorl %ebx, %ebx
0x45, 0x31, 0xc0, //0x00000115 xorl %r8d, %r8d
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000118 .p2align 4, 0x90
//0x00000120 LBB0_10
0x83, 0xfb, 0x12, //0x00000120 cmpl $18, %ebx
0x0f, 0x8f, 0x17, 0x00, 0x00, 0x00, //0x00000123 jg LBB0_12
0x4b, 0x8d, 0x3c, 0x80, //0x00000129 leaq (%r8,%r8,4), %rdi
0x41, 0x0f, 0xb6, 0xf3, //0x0000012d movzbl %r11b, %esi
0x44, 0x01, 0xd6, //0x00000131 addl %r10d, %esi
0x4c, 0x8d, 0x04, 0x7e, //0x00000134 leaq (%rsi,%rdi,2), %r8
0x83, 0xc3, 0x01, //0x00000138 addl $1, %ebx
0xe9, 0x03, 0x00, 0x00, 0x00, //0x0000013b jmp LBB0_13
//0x00000140 .p2align 4, 0x90
//0x00000140 LBB0_12
0x83, 0xc2, 0x01, //0x00000140 addl $1, %edx
//0x00000143 LBB0_13
0x49, 0x39, 0xce, //0x00000143 cmpq %rcx, %r14
0x0f, 0x84, 0x94, 0x00, 0x00, 0x00, //0x00000146 je LBB0_24
0x45, 0x0f, 0xb6, 0x1c, 0x09, //0x0000014c movzbl (%r9,%rcx), %r11d
0x41, 0x8d, 0x43, 0xd0, //0x00000151 leal $-48(%r11), %eax
0x48, 0x83, 0xc1, 0x01, //0x00000155 addq $1, %rcx
0x3c, 0x0a, //0x00000159 cmpb $10, %al
0x0f, 0x82, 0xbf, 0xff, 0xff, 0xff, //0x0000015b jb LBB0_10
0x41, 0x80, 0xfb, 0x2e, //0x00000161 cmpb $46, %r11b
0x0f, 0x85, 0x29, 0x03, 0x00, 0x00, //0x00000165 jne LBB0_25
0x49, 0xc7, 0x07, 0x08, 0x00, 0x00, 0x00, //0x0000016b movq $8, (%r15)
0x4c, 0x89, 0xf7, //0x00000172 movq %r14, %rdi
0x4c, 0x39, 0xf1, //0x00000175 cmpq %r14, %rcx
0x0f, 0x83, 0x03, 0x03, 0x00, 0x00, //0x00000178 jae LBB0_68
0x41, 0x8a, 0x04, 0x09, //0x0000017e movb (%r9,%rcx), %al
0x04, 0xd0, //0x00000182 addb $-48, %al
0x3c, 0x0a, //0x00000184 cmpb $10, %al
0x0f, 0x83, 0xbc, 0x06, 0x00, 0x00, //0x00000186 jae LBB0_107
0xc7, 0x45, 0xc0, 0x00, 0x00, 0x00, 0x00, //0x0000018c movl $0, $-64(%rbp)
0xe9, 0x4e, 0x00, 0x00, 0x00, //0x00000193 jmp LBB0_27
//0x00000198 LBB0_19
0x48, 0x89, 0x16, //0x00000198 movq %rdx, (%rsi)
0x49, 0xc7, 0x07, 0xff, 0xff, 0xff, 0xff, //0x0000019b movq $-1, (%r15)
0xe9, 0x40, 0x1d, 0x00, 0x00, //0x000001a2 jmp LBB0_434
//0x000001a7 LBB0_20
0x41, 0x89, 0xdb, //0x000001a7 movl %ebx, %r11d
0x41, 0x8d, 0x43, 0xd0, //0x000001aa leal $-48(%r11), %eax
0x3c, 0x0a, //0x000001ae cmpb $10, %al
0x0f, 0x82, 0xfa, 0xfe, 0xff, 0xff, //0x000001b0 jb LBB0_4
//0x000001b6 LBB0_21
0x48, 0x89, 0x0e, //0x000001b6 movq %rcx, (%rsi)
0x49, 0xc7, 0x07, 0xfe, 0xff, 0xff, 0xff, //0x000001b9 movq $-2, (%r15)
0xe9, 0x22, 0x1d, 0x00, 0x00, //0x000001c0 jmp LBB0_434
//0x000001c5 LBB0_22
0x31, 0xd2, //0x000001c5 xorl %edx, %edx
0x31, 0xdb, //0x000001c7 xorl %ebx, %ebx
0x45, 0x31, 0xc0, //0x000001c9 xorl %r8d, %r8d
//0x000001cc LBB0_26
0x4c, 0x89, 0xf7, //0x000001cc movq %r14, %rdi
0xe9, 0x12, 0x00, 0x00, 0x00, //0x000001cf jmp LBB0_27
//0x000001d4 LBB0_23
0x48, 0x8b, 0x4d, 0xa8, //0x000001d4 movq $-88(%rbp), %rcx
0x48, 0x89, 0x01, //0x000001d8 movq %rax, (%rcx)
0xe9, 0x07, 0x1d, 0x00, 0x00, //0x000001db jmp LBB0_434
//0x000001e0 LBB0_24
0x4c, 0x89, 0xf7, //0x000001e0 movq %r14, %rdi
0x4c, 0x89, 0xf1, //0x000001e3 movq %r14, %rcx
//0x000001e6 LBB0_27
0x45, 0x31, 0xdb, //0x000001e6 xorl %r11d, %r11d
0x85, 0xd2, //0x000001e9 testl %edx, %edx
0x41, 0x0f, 0x9f, 0xc3, //0x000001eb setg %r11b
0x4d, 0x85, 0xc0, //0x000001ef testq %r8, %r8
0x0f, 0x85, 0x64, 0x00, 0x00, 0x00, //0x000001f2 jne LBB0_36
0x85, 0xd2, //0x000001f8 testl %edx, %edx
0x0f, 0x85, 0x5c, 0x00, 0x00, 0x00, //0x000001fa jne LBB0_36
0x48, 0x39, 0xf9, //0x00000200 cmpq %rdi, %rcx
0x0f, 0x83, 0x4c, 0x00, 0x00, 0x00, //0x00000203 jae LBB0_34
0x41, 0x89, 0xca, //0x00000209 movl %ecx, %r10d
0x41, 0x29, 0xfa, //0x0000020c subl %edi, %r10d
0x31, 0xdb, //0x0000020f xorl %ebx, %ebx
0x31, 0xd2, //0x00000211 xorl %edx, %edx
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000213 .p2align 4, 0x90
//0x00000220 LBB0_31
0x41, 0x80, 0x3c, 0x09, 0x30, //0x00000220 cmpb $48, (%r9,%rcx)
0x0f, 0x85, 0x2e, 0x00, 0x00, 0x00, //0x00000225 jne LBB0_35
0x48, 0x83, 0xc1, 0x01, //0x0000022b addq $1, %rcx
0x83, 0xc2, 0xff, //0x0000022f addl $-1, %edx
0x48, 0x39, 0xcf, //0x00000232 cmpq %rcx, %rdi
0x0f, 0x85, 0xe5, 0xff, 0xff, 0xff, //0x00000235 jne LBB0_31
0x45, 0x31, 0xc0, //0x0000023b xorl %r8d, %r8d
0x80, 0x7d, 0xc0, 0x00, //0x0000023e cmpb $0, $-64(%rbp)
0x48, 0x89, 0x7d, 0x98, //0x00000242 movq %rdi, $-104(%rbp)
0x44, 0x89, 0x5d, 0xa0, //0x00000246 movl %r11d, $-96(%rbp)
0x0f, 0x85, 0x31, 0x01, 0x00, 0x00, //0x0000024a jne LBB0_55
0xe9, 0x62, 0x01, 0x00, 0x00, //0x00000250 jmp LBB0_59
//0x00000255 LBB0_34
0x31, 0xd2, //0x00000255 xorl %edx, %edx
0x31, 0xdb, //0x00000257 xorl %ebx, %ebx
//0x00000259 LBB0_35
0x45, 0x31, 0xc0, //0x00000259 xorl %r8d, %r8d
//0x0000025c LBB0_36
0x48, 0x39, 0xf9, //0x0000025c cmpq %rdi, %rcx
0x0f, 0x83, 0x54, 0x00, 0x00, 0x00, //0x0000025f jae LBB0_42
0x83, 0xfb, 0x12, //0x00000265 cmpl $18, %ebx
0x0f, 0x8f, 0x4b, 0x00, 0x00, 0x00, //0x00000268 jg LBB0_42
0x41, 0xba, 0xd0, 0xff, 0xff, 0xff, //0x0000026e movl $4294967248, %r10d
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000274 .p2align 4, 0x90
//0x00000280 LBB0_39
0x41, 0x0f, 0xb6, 0x34, 0x09, //0x00000280 movzbl (%r9,%rcx), %esi
0x8d, 0x46, 0xd0, //0x00000285 leal $-48(%rsi), %eax
0x3c, 0x09, //0x00000288 cmpb $9, %al
0x0f, 0x87, 0x29, 0x00, 0x00, 0x00, //0x0000028a ja LBB0_42
0x4b, 0x8d, 0x04, 0x80, //0x00000290 leaq (%r8,%r8,4), %rax
0x44, 0x01, 0xd6, //0x00000294 addl %r10d, %esi
0x4c, 0x8d, 0x04, 0x46, //0x00000297 leaq (%rsi,%rax,2), %r8
0x83, 0xc2, 0xff, //0x0000029b addl $-1, %edx
0x48, 0x83, 0xc1, 0x01, //0x0000029e addq $1, %rcx
0x48, 0x39, 0xf9, //0x000002a2 cmpq %rdi, %rcx
0x0f, 0x83, 0x0e, 0x00, 0x00, 0x00, //0x000002a5 jae LBB0_42
0x8d, 0x43, 0x01, //0x000002ab leal $1(%rbx), %eax
0x83, 0xfb, 0x12, //0x000002ae cmpl $18, %ebx
0x89, 0xc3, //0x000002b1 movl %eax, %ebx
0x0f, 0x8c, 0xc7, 0xff, 0xff, 0xff, //0x000002b3 jl LBB0_39
//0x000002b9 LBB0_42
0x48, 0x39, 0xf9, //0x000002b9 cmpq %rdi, %rcx
0x0f, 0x83, 0xa7, 0x00, 0x00, 0x00, //0x000002bc jae LBB0_54
0x41, 0x8a, 0x04, 0x09, //0x000002c2 movb (%r9,%rcx), %al
0x8d, 0x70, 0xd0, //0x000002c6 leal $-48(%rax), %esi
0x40, 0x80, 0xfe, 0x09, //0x000002c9 cmpb $9, %sil
0x0f, 0x87, 0x32, 0x00, 0x00, 0x00, //0x000002cd ja LBB0_48
0x48, 0x8d, 0x77, 0xff, //0x000002d3 leaq $-1(%rdi), %rsi
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x000002d7 .p2align 4, 0x90
//0x000002e0 LBB0_45
0x48, 0x39, 0xce, //0x000002e0 cmpq %rcx, %rsi
0x0f, 0x84, 0xb4, 0x01, 0x00, 0x00, //0x000002e3 je LBB0_69
0x41, 0x0f, 0xb6, 0x44, 0x09, 0x01, //0x000002e9 movzbl $1(%r9,%rcx), %eax
0x8d, 0x58, 0xd0, //0x000002ef leal $-48(%rax), %ebx
0x48, 0x83, 0xc1, 0x01, //0x000002f2 addq $1, %rcx
0x80, 0xfb, 0x09, //0x000002f6 cmpb $9, %bl
0x0f, 0x86, 0xe1, 0xff, 0xff, 0xff, //0x000002f9 jbe LBB0_45
0x41, 0xbb, 0x01, 0x00, 0x00, 0x00, //0x000002ff movl $1, %r11d
//0x00000305 LBB0_48
0x0c, 0x20, //0x00000305 orb $32, %al
0x3c, 0x65, //0x00000307 cmpb $101, %al
0x0f, 0x85, 0x5a, 0x00, 0x00, 0x00, //0x00000309 jne LBB0_54
0x48, 0x8d, 0x41, 0x01, //0x0000030f leaq $1(%rcx), %rax
0x49, 0xc7, 0x07, 0x08, 0x00, 0x00, 0x00, //0x00000313 movq $8, (%r15)
0x48, 0x39, 0xf8, //0x0000031a cmpq %rdi, %rax
0x0f, 0x83, 0x5e, 0x01, 0x00, 0x00, //0x0000031d jae LBB0_68
0x44, 0x89, 0x5d, 0xa0, //0x00000323 movl %r11d, $-96(%rbp)
0x41, 0x8a, 0x1c, 0x01, //0x00000327 movb (%r9,%rax), %bl
0x80, 0xfb, 0x2d, //0x0000032b cmpb $45, %bl
0x0f, 0x84, 0x0f, 0x00, 0x00, 0x00, //0x0000032e je LBB0_52
0x41, 0xbb, 0x01, 0x00, 0x00, 0x00, //0x00000334 movl $1, %r11d
0x80, 0xfb, 0x2b, //0x0000033a cmpb $43, %bl
0x0f, 0x85, 0xf7, 0x04, 0x00, 0x00, //0x0000033d jne LBB0_105
//0x00000343 LBB0_52
0x48, 0x83, 0xc1, 0x02, //0x00000343 addq $2, %rcx
0x4c, 0x39, 0xf1, //0x00000347 cmpq %r14, %rcx
0x0f, 0x83, 0x0b, 0x05, 0x00, 0x00, //0x0000034a jae LBB0_108
0x31, 0xc0, //0x00000350 xorl %eax, %eax
0x80, 0xfb, 0x2b, //0x00000352 cmpb $43, %bl
0x0f, 0x94, 0xc0, //0x00000355 sete %al
0x44, 0x8d, 0x1c, 0x00, //0x00000358 leal (%rax,%rax), %r11d
0x41, 0x83, 0xc3, 0xff, //0x0000035c addl $-1, %r11d
0x41, 0x8a, 0x1c, 0x09, //0x00000360 movb (%r9,%rcx), %bl
0xe9, 0xd4, 0x04, 0x00, 0x00, //0x00000364 jmp LBB0_106
//0x00000369 LBB0_54
0x41, 0x89, 0xd2, //0x00000369 movl %edx, %r10d
0x48, 0x89, 0xcf, //0x0000036c movq %rcx, %rdi
0x80, 0x7d, 0xc0, 0x00, //0x0000036f cmpb $0, $-64(%rbp)
0x48, 0x89, 0x7d, 0x98, //0x00000373 movq %rdi, $-104(%rbp)
0x44, 0x89, 0x5d, 0xa0, //0x00000377 movl %r11d, $-96(%rbp)
0x0f, 0x84, 0x36, 0x00, 0x00, 0x00, //0x0000037b je LBB0_59
//0x00000381 LBB0_55
0x45, 0x85, 0xd2, //0x00000381 testl %r10d, %r10d
0x0f, 0x85, 0x26, 0x00, 0x00, 0x00, //0x00000384 jne LBB0_58
0x48, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, //0x0000038a movabsq $-9223372036854775808, %rax
0x48, 0x63, 0x4d, 0xc8, //0x00000394 movslq $-56(%rbp), %rcx
0x4d, 0x85, 0xc0, //0x00000398 testq %r8, %r8
0x0f, 0x89, 0x67, 0x01, 0x00, 0x00, //0x0000039b jns LBB0_75
0x4c, 0x89, 0xc2, //0x000003a1 movq %r8, %rdx
0x48, 0x21, 0xca, //0x000003a4 andq %rcx, %rdx
0x48, 0x39, 0xc2, //0x000003a7 cmpq %rax, %rdx
0x0f, 0x84, 0x58, 0x01, 0x00, 0x00, //0x000003aa je LBB0_75
//0x000003b0 LBB0_58
0x49, 0xc7, 0x07, 0x08, 0x00, 0x00, 0x00, //0x000003b0 movq $8, (%r15)
//0x000003b7 LBB0_59
0x49, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, //0x000003b7 movabsq $-9223372036854775808, %r14
0x48, 0xb8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, //0x000003c1 movabsq $4503599627370495, %rax
0x48, 0x8d, 0x50, 0x01, //0x000003cb leaq $1(%rax), %rdx
0x49, 0x39, 0xd0, //0x000003cf cmpq %rdx, %r8
0x0f, 0x83, 0x04, 0x01, 0x00, 0x00, //0x000003d2 jae LBB0_72
0x66, 0x49, 0x0f, 0x6e, 0xc0, //0x000003d8 movq %r8, %xmm0
0x66, 0x0f, 0x62, 0x05, 0x1b, 0xfc, 0xff, 0xff, //0x000003dd punpckldq $-997(%rip), %xmm0 /* LCPI0_0+0(%rip) */
0x66, 0x0f, 0x5c, 0x05, 0x23, 0xfc, 0xff, 0xff, //0x000003e5 subpd $-989(%rip), %xmm0 /* LCPI0_1+0(%rip) */
0x66, 0x0f, 0x28, 0xc8, //0x000003ed movapd %xmm0, %xmm1
0x66, 0x0f, 0x15, 0xc8, //0x000003f1 unpckhpd %xmm0, %xmm1
0xf2, 0x0f, 0x58, 0xc8, //0x000003f5 addsd %xmm0, %xmm1
0x48, 0x8b, 0x45, 0xc8, //0x000003f9 movq $-56(%rbp), %rax
0xc1, 0xe8, 0x1f, //0x000003fd shrl $31, %eax
0x48, 0xc1, 0xe0, 0x3f, //0x00000400 shlq $63, %rax
0x66, 0x48, 0x0f, 0x6e, 0xc0, //0x00000404 movq %rax, %xmm0
0x66, 0x0f, 0xeb, 0xc1, //0x00000409 por %xmm1, %xmm0
0x45, 0x85, 0xd2, //0x0000040d testl %r10d, %r10d
0x0f, 0x84, 0x9a, 0x1a, 0x00, 0x00, //0x00000410 je LBB0_431
0x4d, 0x85, 0xc0, //0x00000416 testq %r8, %r8
0x0f, 0x84, 0x91, 0x1a, 0x00, 0x00, //0x00000419 je LBB0_431
0x41, 0x8d, 0x42, 0xff, //0x0000041f leal $-1(%r10), %eax
0x83, 0xf8, 0x24, //0x00000423 cmpl $36, %eax
0x0f, 0x87, 0x91, 0x00, 0x00, 0x00, //0x00000426 ja LBB0_70
0x44, 0x89, 0xd0, //0x0000042c movl %r10d, %eax
0x41, 0x83, 0xfa, 0x17, //0x0000042f cmpl $23, %r10d
0x0f, 0x8c, 0x15, 0x00, 0x00, 0x00, //0x00000433 jl LBB0_65
0x41, 0x8d, 0x42, 0xea, //0x00000439 leal $-22(%r10), %eax
0x48, 0x8d, 0x0d, 0xbc, 0x1a, 0x00, 0x00, //0x0000043d leaq $6844(%rip), %rcx /* _P10_TAB+0(%rip) */
0xf2, 0x0f, 0x59, 0x04, 0xc1, //0x00000444 mulsd (%rcx,%rax,8), %xmm0
0xb8, 0x16, 0x00, 0x00, 0x00, //0x00000449 movl $22, %eax
//0x0000044e LBB0_65
0x66, 0x0f, 0x2e, 0x05, 0xca, 0xfb, 0xff, 0xff, //0x0000044e ucomisd $-1078(%rip), %xmm0 /* LCPI0_2+0(%rip) */
0x0f, 0x87, 0xf0, 0x00, 0x00, 0x00, //0x00000456 ja LBB0_76
0xf2, 0x0f, 0x10, 0x0d, 0xc4, 0xfb, 0xff, 0xff, //0x0000045c movsd $-1084(%rip), %xmm1 /* LCPI0_3+0(%rip) */
0x66, 0x0f, 0x2e, 0xc8, //0x00000464 ucomisd %xmm0, %xmm1
0x0f, 0x87, 0xde, 0x00, 0x00, 0x00, //0x00000468 ja LBB0_76
0x89, 0xc0, //0x0000046e movl %eax, %eax
0x48, 0x8d, 0x0d, 0x89, 0x1a, 0x00, 0x00, //0x00000470 leaq $6793(%rip), %rcx /* _P10_TAB+0(%rip) */
0xf2, 0x0f, 0x59, 0x04, 0xc1, //0x00000477 mulsd (%rcx,%rax,8), %xmm0
0xe9, 0x2f, 0x1a, 0x00, 0x00, //0x0000047c jmp LBB0_431
//0x00000481 LBB0_68
0x48, 0x8b, 0x45, 0xa8, //0x00000481 movq $-88(%rbp), %rax
0x48, 0x89, 0x38, //0x00000485 movq %rdi, (%rax)
0x49, 0xc7, 0x07, 0xff, 0xff, 0xff, 0xff, //0x00000488 movq $-1, (%r15)
0xe9, 0x53, 0x1a, 0x00, 0x00, //0x0000048f jmp LBB0_434
//0x00000494 LBB0_25
0x48, 0x83, 0xc1, 0xff, //0x00000494 addq $-1, %rcx
0xe9, 0x2f, 0xfd, 0xff, 0xff, //0x00000498 jmp LBB0_26
//0x0000049d LBB0_69
0x41, 0xbb, 0x01, 0x00, 0x00, 0x00, //0x0000049d movl $1, %r11d
0x41, 0x89, 0xd2, //0x000004a3 movl %edx, %r10d
0x80, 0x7d, 0xc0, 0x00, //0x000004a6 cmpb $0, $-64(%rbp)
0x48, 0x89, 0x7d, 0x98, //0x000004aa movq %rdi, $-104(%rbp)
0x44, 0x89, 0x5d, 0xa0, //0x000004ae movl %r11d, $-96(%rbp)
0x0f, 0x85, 0xc9, 0xfe, 0xff, 0xff, //0x000004b2 jne LBB0_55
0xe9, 0xfa, 0xfe, 0xff, 0xff, //0x000004b8 jmp LBB0_59
//0x000004bd LBB0_70
0x41, 0x83, 0xfa, 0xea, //0x000004bd cmpl $-22, %r10d
0x0f, 0x82, 0x15, 0x00, 0x00, 0x00, //0x000004c1 jb LBB0_72
0x41, 0xf7, 0xda, //0x000004c7 negl %r10d
0x48, 0x8d, 0x05, 0x2f, 0x1a, 0x00, 0x00, //0x000004ca leaq $6703(%rip), %rax /* _P10_TAB+0(%rip) */
0xf2, 0x42, 0x0f, 0x5e, 0x04, 0xd0, //0x000004d1 divsd (%rax,%r10,8), %xmm0
0xe9, 0xd4, 0x19, 0x00, 0x00, //0x000004d7 jmp LBB0_431
//0x000004dc LBB0_72
0x48, 0x89, 0x55, 0x90, //0x000004dc movq %rdx, $-112(%rbp)
0x41, 0x8d, 0x82, 0x5c, 0x01, 0x00, 0x00, //0x000004e0 leal $348(%r10), %eax
0x3d, 0xb7, 0x02, 0x00, 0x00, //0x000004e7 cmpl $695, %eax
0x0f, 0x87, 0x75, 0x01, 0x00, 0x00, //0x000004ec ja LBB0_87
0x4d, 0x85, 0xc0, //0x000004f2 testq %r8, %r8
0x0f, 0x84, 0x65, 0x00, 0x00, 0x00, //0x000004f5 je LBB0_77
//0x000004fb LBB0_74
0x49, 0x0f, 0xbd, 0xc8, //0x000004fb bsrq %r8, %rcx
0x48, 0x83, 0xf1, 0x3f, //0x000004ff xorq $63, %rcx
0xe9, 0x5d, 0x00, 0x00, 0x00, //0x00000503 jmp LBB0_78
//0x00000508 LBB0_75
0x66, 0x49, 0x0f, 0x6e, 0xc0, //0x00000508 movq %r8, %xmm0
0x4c, 0x0f, 0xaf, 0xc1, //0x0000050d imulq %rcx, %r8
0x66, 0x0f, 0x62, 0x05, 0xe7, 0xfa, 0xff, 0xff, //0x00000511 punpckldq $-1305(%rip), %xmm0 /* LCPI0_0+0(%rip) */
0x66, 0x0f, 0x5c, 0x05, 0xef, 0xfa, 0xff, 0xff, //0x00000519 subpd $-1297(%rip), %xmm0 /* LCPI0_1+0(%rip) */
0x4d, 0x89, 0x47, 0x10, //0x00000521 movq %r8, $16(%r15)
0x66, 0x0f, 0x28, 0xc8, //0x00000525 movapd %xmm0, %xmm1
0x66, 0x0f, 0x15, 0xc8, //0x00000529 unpckhpd %xmm0, %xmm1
0xf2, 0x0f, 0x58, 0xc8, //0x0000052d addsd %xmm0, %xmm1
0x48, 0x21, 0xc8, //0x00000531 andq %rcx, %rax
0x66, 0x48, 0x0f, 0x7e, 0xc9, //0x00000534 movq %xmm1, %rcx
0x48, 0x09, 0xc1, //0x00000539 orq %rax, %rcx
0x49, 0x89, 0x4f, 0x08, //0x0000053c movq %rcx, $8(%r15)
0x48, 0x8b, 0x45, 0xa8, //0x00000540 movq $-88(%rbp), %rax
0x48, 0x89, 0x38, //0x00000544 movq %rdi, (%rax)
0xe9, 0x9b, 0x19, 0x00, 0x00, //0x00000547 jmp LBB0_434
//0x0000054c LBB0_76
0x48, 0x89, 0x55, 0x90, //0x0000054c movq %rdx, $-112(%rbp)
0x41, 0x8d, 0x82, 0x5c, 0x01, 0x00, 0x00, //0x00000550 leal $348(%r10), %eax
0x4d, 0x85, 0xc0, //0x00000557 testq %r8, %r8
0x0f, 0x85, 0x9b, 0xff, 0xff, 0xff, //0x0000055a jne LBB0_74
//0x00000560 LBB0_77
0xb9, 0x40, 0x00, 0x00, 0x00, //0x00000560 movl $64, %ecx
//0x00000565 LBB0_78
0x4c, 0x89, 0xc3, //0x00000565 movq %r8, %rbx
0x48, 0x89, 0xcf, //0x00000568 movq %rcx, %rdi
0x48, 0xd3, 0xe3, //0x0000056b shlq %cl, %rbx
0x89, 0xc0, //0x0000056e movl %eax, %eax
0x48, 0xc1, 0xe0, 0x04, //0x00000570 shlq $4, %rax
0x48, 0x8d, 0x0d, 0x45, 0x1a, 0x00, 0x00, //0x00000574 leaq $6725(%rip), %rcx /* _POW10_M128_TAB+0(%rip) */
0x48, 0x89, 0x45, 0xc0, //0x0000057b movq %rax, $-64(%rbp)
0x48, 0x8b, 0x44, 0x08, 0x08, //0x0000057f movq $8(%rax,%rcx), %rax
0x48, 0x89, 0x45, 0xc8, //0x00000584 movq %rax, $-56(%rbp)
0x48, 0xf7, 0xe3, //0x00000588 mulq %rbx
0x48, 0x89, 0xc6, //0x0000058b movq %rax, %rsi
0x49, 0x89, 0xd3, //0x0000058e movq %rdx, %r11
0x81, 0xe2, 0xff, 0x01, 0x00, 0x00, //0x00000591 andl $511, %edx
0x48, 0x81, 0xfa, 0xff, 0x01, 0x00, 0x00, //0x00000597 cmpq $511, %rdx
0x0f, 0x85, 0x51, 0x00, 0x00, 0x00, //0x0000059e jne LBB0_83
0x48, 0x89, 0xd9, //0x000005a4 movq %rbx, %rcx
0x48, 0xf7, 0xd1, //0x000005a7 notq %rcx
0x48, 0x39, 0xce, //0x000005aa cmpq %rcx, %rsi
0x0f, 0x86, 0x42, 0x00, 0x00, 0x00, //0x000005ad jbe LBB0_83
0x48, 0x89, 0xd8, //0x000005b3 movq %rbx, %rax
0x48, 0x8d, 0x15, 0x03, 0x1a, 0x00, 0x00, //0x000005b6 leaq $6659(%rip), %rdx /* _POW10_M128_TAB+0(%rip) */
0x48, 0x8b, 0x5d, 0xc0, //0x000005bd movq $-64(%rbp), %rbx
0x48, 0xf7, 0x24, 0x13, //0x000005c1 mulq (%rbx,%rdx)
0x48, 0x01, 0xd6, //0x000005c5 addq %rdx, %rsi
0x49, 0x83, 0xd3, 0x00, //0x000005c8 adcq $0, %r11
0x44, 0x89, 0xda, //0x000005cc movl %r11d, %edx
0x81, 0xe2, 0xff, 0x01, 0x00, 0x00, //0x000005cf andl $511, %edx
0x48, 0x81, 0xfa, 0xff, 0x01, 0x00, 0x00, //0x000005d5 cmpq $511, %rdx
0x0f, 0x85, 0x13, 0x00, 0x00, 0x00, //0x000005dc jne LBB0_83
0x48, 0x83, 0xfe, 0xff, //0x000005e2 cmpq $-1, %rsi
0x0f, 0x85, 0x09, 0x00, 0x00, 0x00, //0x000005e6 jne LBB0_83
0x48, 0x39, 0xc8, //0x000005ec cmpq %rcx, %rax
0x0f, 0x87, 0x72, 0x00, 0x00, 0x00, //0x000005ef ja LBB0_87
//0x000005f5 LBB0_83
0x4c, 0x89, 0xd8, //0x000005f5 movq %r11, %rax
0x48, 0xc1, 0xe8, 0x3f, //0x000005f8 shrq $63, %rax
0x8d, 0x48, 0x09, //0x000005fc leal $9(%rax), %ecx
0x49, 0xd3, 0xeb, //0x000005ff shrq %cl, %r11
0x48, 0x85, 0xf6, //0x00000602 testq %rsi, %rsi
0x0f, 0x85, 0x18, 0x00, 0x00, 0x00, //0x00000605 jne LBB0_86
0x48, 0x85, 0xd2, //0x0000060b testq %rdx, %rdx
0x0f, 0x85, 0x0f, 0x00, 0x00, 0x00, //0x0000060e jne LBB0_86
0x44, 0x89, 0xd9, //0x00000614 movl %r11d, %ecx
0x83, 0xe1, 0x03, //0x00000617 andl $3, %ecx
0x83, 0xf9, 0x01, //0x0000061a cmpl $1, %ecx
0x0f, 0x84, 0x44, 0x00, 0x00, 0x00, //0x0000061d je LBB0_87
//0x00000623 LBB0_86
0x41, 0x69, 0xca, 0x6a, 0x52, 0x03, 0x00, //0x00000623 imull $217706, %r10d, %ecx
0xc1, 0xf9, 0x10, //0x0000062a sarl $16, %ecx
0x81, 0xc1, 0x3f, 0x04, 0x00, 0x00, //0x0000062d addl $1087, %ecx
0x4c, 0x63, 0xd1, //0x00000633 movslq %ecx, %r10
0x4c, 0x89, 0xd6, //0x00000636 movq %r10, %rsi
0x48, 0x29, 0xfe, //0x00000639 subq %rdi, %rsi
0x44, 0x89, 0xda, //0x0000063c movl %r11d, %edx
0x83, 0xe2, 0x01, //0x0000063f andl $1, %edx
0x4c, 0x01, 0xda, //0x00000642 addq %r11, %rdx
0x48, 0x89, 0xd1, //0x00000645 movq %rdx, %rcx
0x48, 0xc1, 0xe9, 0x36, //0x00000648 shrq $54, %rcx
0x48, 0x01, 0xc6, //0x0000064c addq %rax, %rsi
0x48, 0x83, 0xf9, 0x01, //0x0000064f cmpq $1, %rcx
0x48, 0x83, 0xde, 0x00, //0x00000653 sbbq $0, %rsi
0x48, 0x8d, 0x46, 0xff, //0x00000657 leaq $-1(%rsi), %rax
0x48, 0x3d, 0xfd, 0x07, 0x00, 0x00, //0x0000065b cmpq $2045, %rax
0x0f, 0x86, 0x55, 0x00, 0x00, 0x00, //0x00000661 jbe LBB0_92
//0x00000667 LBB0_87
0x48, 0x8b, 0x45, 0xa8, //0x00000667 movq $-88(%rbp), %rax
0x48, 0x8b, 0x08, //0x0000066b movq (%rax), %rcx
0x49, 0x8d, 0x14, 0x09, //0x0000066e leaq (%r9,%rcx), %rdx
0x4c, 0x8b, 0x55, 0x98, //0x00000672 movq $-104(%rbp), %r10
0x4c, 0x89, 0xd0, //0x00000676 movq %r10, %rax
0x48, 0x29, 0xc8, //0x00000679 subq %rcx, %rax
0x48, 0x89, 0x45, 0xc8, //0x0000067c movq %rax, $-56(%rbp)
0x4d, 0x85, 0xed, //0x00000680 testq %r13, %r13
0x0f, 0x84, 0x69, 0x03, 0x00, 0x00, //0x00000683 je LBB0_129
0x41, 0xc6, 0x04, 0x24, 0x00, //0x00000689 movb $0, (%r12)
0x49, 0x83, 0xfd, 0x01, //0x0000068e cmpq $1, %r13
0x0f, 0x84, 0x5a, 0x03, 0x00, 0x00, //0x00000692 je LBB0_129
0x4d, 0x8d, 0x45, 0xff, //0x00000698 leaq $-1(%r13), %r8
0xb8, 0x01, 0x00, 0x00, 0x00, //0x0000069c movl $1, %eax
0x49, 0x83, 0xf8, 0x08, //0x000006a1 cmpq $8, %r8
0x0f, 0x82, 0x35, 0x03, 0x00, 0x00, //0x000006a5 jb LBB0_128
0x49, 0x83, 0xf8, 0x20, //0x000006ab cmpq $32, %r8
0x0f, 0x83, 0x12, 0x02, 0x00, 0x00, //0x000006af jae LBB0_113
0x31, 0xf6, //0x000006b5 xorl %esi, %esi
0xe9, 0xce, 0x02, 0x00, 0x00, //0x000006b7 jmp LBB0_122
//0x000006bc LBB0_92
0x48, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, //0x000006bc movabsq $18014398509481984, %rax
0x48, 0x39, 0xc2, //0x000006c6 cmpq %rax, %rdx
0xb1, 0x02, //0x000006c9 movb $2, %cl
0x80, 0xd9, 0x00, //0x000006cb sbbb $0, %cl
0x48, 0xd3, 0xea, //0x000006ce shrq %cl, %rdx
0x48, 0xc1, 0xe6, 0x34, //0x000006d1 shlq $52, %rsi
0x48, 0xb8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, //0x000006d5 movabsq $4503599627370495, %rax
0x48, 0x21, 0xc2, //0x000006df andq %rax, %rdx
0x48, 0x09, 0xf2, //0x000006e2 orq %rsi, %rdx
0x48, 0x89, 0xd0, //0x000006e5 movq %rdx, %rax
0x4c, 0x09, 0xf0, //0x000006e8 orq %r14, %rax
0x80, 0x7d, 0xb8, 0x2d, //0x000006eb cmpb $45, $-72(%rbp)
0x48, 0x0f, 0x45, 0xc2, //0x000006ef cmovneq %rdx, %rax
0x66, 0x48, 0x0f, 0x6e, 0xc0, //0x000006f3 movq %rax, %xmm0
0x83, 0x7d, 0xa0, 0x00, //0x000006f8 cmpl $0, $-96(%rbp)
0x0f, 0x84, 0xae, 0x17, 0x00, 0x00, //0x000006fc je LBB0_431
0xbe, 0x40, 0x00, 0x00, 0x00, //0x00000702 movl $64, %esi
0x49, 0xff, 0xc0, //0x00000707 incq %r8
0x0f, 0x84, 0x08, 0x00, 0x00, 0x00, //0x0000070a je LBB0_95
0x49, 0x0f, 0xbd, 0xf0, //0x00000710 bsrq %r8, %rsi
0x48, 0x83, 0xf6, 0x3f, //0x00000714 xorq $63, %rsi
//0x00000718 LBB0_95
0x89, 0xf1, //0x00000718 movl %esi, %ecx
0x49, 0xd3, 0xe0, //0x0000071a shlq %cl, %r8
0x48, 0x8b, 0x45, 0xc8, //0x0000071d movq $-56(%rbp), %rax
0x49, 0xf7, 0xe0, //0x00000721 mulq %r8
0x49, 0x89, 0xc3, //0x00000724 movq %rax, %r11
0x48, 0x89, 0xd3, //0x00000727 movq %rdx, %rbx
0x81, 0xe2, 0xff, 0x01, 0x00, 0x00, //0x0000072a andl $511, %edx
0x48, 0x81, 0xfa, 0xff, 0x01, 0x00, 0x00, //0x00000730 cmpq $511, %rdx
0x0f, 0x85, 0x50, 0x00, 0x00, 0x00, //0x00000737 jne LBB0_100
0x4c, 0x89, 0xc1, //0x0000073d movq %r8, %rcx
0x48, 0xf7, 0xd1, //0x00000740 notq %rcx
0x49, 0x39, 0xcb, //0x00000743 cmpq %rcx, %r11
0x0f, 0x86, 0x41, 0x00, 0x00, 0x00, //0x00000746 jbe LBB0_100
0x4c, 0x89, 0xc0, //0x0000074c movq %r8, %rax
0x48, 0x8d, 0x15, 0x6a, 0x18, 0x00, 0x00, //0x0000074f leaq $6250(%rip), %rdx /* _POW10_M128_TAB+0(%rip) */
0x48, 0x8b, 0x7d, 0xc0, //0x00000756 movq $-64(%rbp), %rdi
0x48, 0xf7, 0x24, 0x17, //0x0000075a mulq (%rdi,%rdx)
0x49, 0x01, 0xd3, //0x0000075e addq %rdx, %r11
0x48, 0x83, 0xd3, 0x00, //0x00000761 adcq $0, %rbx
0x89, 0xda, //0x00000765 movl %ebx, %edx
0x81, 0xe2, 0xff, 0x01, 0x00, 0x00, //0x00000767 andl $511, %edx
0x48, 0x81, 0xfa, 0xff, 0x01, 0x00, 0x00, //0x0000076d cmpq $511, %rdx
0x0f, 0x85, 0x13, 0x00, 0x00, 0x00, //0x00000774 jne LBB0_100
0x49, 0x83, 0xfb, 0xff, //0x0000077a cmpq $-1, %r11
0x0f, 0x85, 0x09, 0x00, 0x00, 0x00, //0x0000077e jne LBB0_100
0x48, 0x39, 0xc8, //0x00000784 cmpq %rcx, %rax
0x0f, 0x87, 0xda, 0xfe, 0xff, 0xff, //0x00000787 ja LBB0_87
//0x0000078d LBB0_100
0x48, 0x89, 0xd8, //0x0000078d movq %rbx, %rax
0x48, 0xc1, 0xe8, 0x3f, //0x00000790 shrq $63, %rax
0x8d, 0x48, 0x09, //0x00000794 leal $9(%rax), %ecx
0x48, 0xd3, 0xeb, //0x00000797 shrq %cl, %rbx
0x4d, 0x85, 0xdb, //0x0000079a testq %r11, %r11
0x0f, 0x85, 0x17, 0x00, 0x00, 0x00, //0x0000079d jne LBB0_103
0x48, 0x85, 0xd2, //0x000007a3 testq %rdx, %rdx
0x0f, 0x85, 0x0e, 0x00, 0x00, 0x00, //0x000007a6 jne LBB0_103
0x89, 0xd9, //0x000007ac movl %ebx, %ecx
0x83, 0xe1, 0x03, //0x000007ae andl $3, %ecx
0x83, 0xf9, 0x01, //0x000007b1 cmpl $1, %ecx
0x0f, 0x84, 0xad, 0xfe, 0xff, 0xff, //0x000007b4 je LBB0_87
//0x000007ba LBB0_103
0x49, 0x29, 0xf2, //0x000007ba subq %rsi, %r10
0x89, 0xda, //0x000007bd movl %ebx, %edx
0x83, 0xe2, 0x01, //0x000007bf andl $1, %edx
0x48, 0x01, 0xda, //0x000007c2 addq %rbx, %rdx
0x49, 0x01, 0xc2, //0x000007c5 addq %rax, %r10
0x48, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, //0x000007c8 movabsq $18014398509481984, %rax
0x48, 0x39, 0xc2, //0x000007d2 cmpq %rax, %rdx
0x49, 0x83, 0xda, 0x00, //0x000007d5 sbbq $0, %r10
0x49, 0x8d, 0x42, 0xff, //0x000007d9 leaq $-1(%r10), %rax
0x48, 0x3d, 0xfd, 0x07, 0x00, 0x00, //0x000007dd cmpq $2045, %rax
0x0f, 0x87, 0x7e, 0xfe, 0xff, 0xff, //0x000007e3 ja LBB0_87
0x48, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, //0x000007e9 movabsq $18014398509481984, %rax
0x48, 0x39, 0xc2, //0x000007f3 cmpq %rax, %rdx
0xb1, 0x02, //0x000007f6 movb $2, %cl
0x80, 0xd9, 0x00, //0x000007f8 sbbb $0, %cl
0x48, 0xd3, 0xea, //0x000007fb shrq %cl, %rdx
0x49, 0xc1, 0xe2, 0x34, //0x000007fe shlq $52, %r10
0x48, 0xb8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, //0x00000802 movabsq $4503599627370495, %rax
0x48, 0x21, 0xc2, //0x0000080c andq %rax, %rdx
0x4c, 0x09, 0xd2, //0x0000080f orq %r10, %rdx
0x48, 0x89, 0xd0, //0x00000812 movq %rdx, %rax
0x4c, 0x09, 0xf0, //0x00000815 orq %r14, %rax
0x80, 0x7d, 0xb8, 0x2d, //0x00000818 cmpb $45, $-72(%rbp)
0x48, 0x0f, 0x45, 0xc2, //0x0000081c cmovneq %rdx, %rax
0x66, 0x48, 0x0f, 0x6e, 0xc8, //0x00000820 movq %rax, %xmm1
0x66, 0x0f, 0x2e, 0xc1, //0x00000825 ucomisd %xmm1, %xmm0
0x0f, 0x85, 0x38, 0xfe, 0xff, 0xff, //0x00000829 jne LBB0_87
0x0f, 0x8b, 0x7b, 0x16, 0x00, 0x00, //0x0000082f jnp LBB0_431
0xe9, 0x2d, 0xfe, 0xff, 0xff, //0x00000835 jmp LBB0_87
//0x0000083a LBB0_105
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | true |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/skip_object.go | vendor/github.com/bytedance/sonic/internal/native/sse/skip_object.go | // 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
import (
`unsafe`
`github.com/bytedance/sonic/internal/native/types`
`github.com/bytedance/sonic/internal/rt`
)
var F_skip_object func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer, flags uint64) (ret int)
var S_skip_object uintptr
//go:nosplit
func skip_object(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) {
return F_skip_object(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)), flags)
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/f32toa_subr.go | vendor/github.com/bytedance/sonic/internal/native/sse/f32toa_subr.go | // +build !noasm !appengine
// Code generated by asm2asm, DO NOT EDIT.
package sse
import (
`github.com/bytedance/sonic/loader`
)
const (
_entry__f32toa = 16
)
const (
_stack__f32toa = 64
)
const (
_size__f32toa = 3696
)
var (
_pcsp__f32toa = [][2]uint32{
{0x1, 0},
{0x6, 8},
{0x8, 16},
{0xa, 24},
{0xc, 32},
{0xd, 40},
{0x11, 48},
{0xe3a, 64},
{0xe3b, 48},
{0xe3d, 40},
{0xe3f, 32},
{0xe41, 24},
{0xe43, 16},
{0xe44, 8},
{0xe45, 0},
{0xe70, 64},
}
)
var _cfunc_f32toa = []loader.CFunc{
{"_f32toa_entry", 0, _entry__f32toa, 0, nil},
{"_f32toa", _entry__f32toa, _size__f32toa, _stack__f32toa, _pcsp__f32toa},
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/unquote.go | vendor/github.com/bytedance/sonic/internal/native/sse/unquote.go | // 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
import (
`unsafe`
`github.com/bytedance/sonic/internal/rt`
)
var F_unquote func(sp unsafe.Pointer, nb int, dp unsafe.Pointer, ep unsafe.Pointer, flags uint64) (ret int)
var S_unquote uintptr
//go:nosplit
func unquote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, ep *int, flags uint64) (ret int) {
return F_unquote(rt.NoEscape(sp), nb, dp, rt.NoEscape(unsafe.Pointer(ep)), flags)
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/validate_utf8_fast_text_amd64.go | vendor/github.com/bytedance/sonic/internal/native/sse/validate_utf8_fast_text_amd64.go | // +build amd64
// Code generated by asm2asm, DO NOT EDIT.
package sse
var _text_validate_utf8_fast = []byte{
// .p2align 4, 0x90
// _validate_utf8_fast
0x55, // pushq %rbp
0x48, 0x89, 0xe5, //0x00000001 movq %rsp, %rbp
0x53, //0x00000004 pushq %rbx
0x50, //0x00000005 pushq %rax
0x4c, 0x8b, 0x17, //0x00000006 movq (%rdi), %r10
0x4c, 0x8b, 0x5f, 0x08, //0x00000009 movq $8(%rdi), %r11
0x4b, 0x8d, 0x34, 0x1a, //0x0000000d leaq (%r10,%r11), %rsi
0x48, 0x83, 0xc6, 0xfd, //0x00000011 addq $-3, %rsi
0x4c, 0x89, 0xd0, //0x00000015 movq %r10, %rax
0x4c, 0x39, 0xd6, //0x00000018 cmpq %r10, %rsi
0x0f, 0x86, 0xdd, 0x00, 0x00, 0x00, //0x0000001b jbe LBB0_14
0x4c, 0x89, 0xd0, //0x00000021 movq %r10, %rax
0xe9, 0x13, 0x00, 0x00, 0x00, //0x00000024 jmp LBB0_3
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000029 .p2align 4, 0x90
//0x00000030 LBB0_2
0x48, 0x01, 0xd0, //0x00000030 addq %rdx, %rax
0x48, 0x39, 0xf0, //0x00000033 cmpq %rsi, %rax
0x0f, 0x83, 0xc2, 0x00, 0x00, 0x00, //0x00000036 jae LBB0_14
//0x0000003c LBB0_3
0xba, 0x01, 0x00, 0x00, 0x00, //0x0000003c movl $1, %edx
0x80, 0x38, 0x00, //0x00000041 cmpb $0, (%rax)
0x0f, 0x89, 0xe6, 0xff, 0xff, 0xff, //0x00000044 jns LBB0_2
0x8b, 0x38, //0x0000004a movl (%rax), %edi
0x89, 0xf9, //0x0000004c movl %edi, %ecx
0x81, 0xe1, 0xf0, 0xc0, 0xc0, 0x00, //0x0000004e andl $12632304, %ecx
0x81, 0xf9, 0xe0, 0x80, 0x80, 0x00, //0x00000054 cmpl $8421600, %ecx
0x0f, 0x85, 0x30, 0x00, 0x00, 0x00, //0x0000005a jne LBB0_7
0x89, 0xf9, //0x00000060 movl %edi, %ecx
0x81, 0xe1, 0x0f, 0x20, 0x00, 0x00, //0x00000062 andl $8207, %ecx
0x81, 0xf9, 0x0d, 0x20, 0x00, 0x00, //0x00000068 cmpl $8205, %ecx
0x0f, 0x84, 0x1c, 0x00, 0x00, 0x00, //0x0000006e je LBB0_7
0xba, 0x03, 0x00, 0x00, 0x00, //0x00000074 movl $3, %edx
0x85, 0xc9, //0x00000079 testl %ecx, %ecx
0x0f, 0x85, 0xaf, 0xff, 0xff, 0xff, //0x0000007b jne LBB0_2
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000081 .p2align 4, 0x90
//0x00000090 LBB0_7
0x89, 0xf9, //0x00000090 movl %edi, %ecx
0x81, 0xe1, 0xe0, 0xc0, 0x00, 0x00, //0x00000092 andl $49376, %ecx
0x81, 0xf9, 0xc0, 0x80, 0x00, 0x00, //0x00000098 cmpl $32960, %ecx
0x0f, 0x85, 0x10, 0x00, 0x00, 0x00, //0x0000009e jne LBB0_9
0x89, 0xf9, //0x000000a4 movl %edi, %ecx
0xba, 0x02, 0x00, 0x00, 0x00, //0x000000a6 movl $2, %edx
0x83, 0xe1, 0x1e, //0x000000ab andl $30, %ecx
0x0f, 0x85, 0x7c, 0xff, 0xff, 0xff, //0x000000ae jne LBB0_2
//0x000000b4 LBB0_9
0x89, 0xf9, //0x000000b4 movl %edi, %ecx
0x81, 0xe1, 0xf8, 0xc0, 0xc0, 0xc0, //0x000000b6 andl $-1061109512, %ecx
0x81, 0xf9, 0xf0, 0x80, 0x80, 0x80, //0x000000bc cmpl $-2139062032, %ecx
0x0f, 0x85, 0x29, 0x00, 0x00, 0x00, //0x000000c2 jne LBB0_13
0x89, 0xf9, //0x000000c8 movl %edi, %ecx
0x81, 0xe1, 0x07, 0x30, 0x00, 0x00, //0x000000ca andl $12295, %ecx
0x0f, 0x84, 0x1b, 0x00, 0x00, 0x00, //0x000000d0 je LBB0_13
0xba, 0x04, 0x00, 0x00, 0x00, //0x000000d6 movl $4, %edx
0x40, 0xf6, 0xc7, 0x04, //0x000000db testb $4, %dil
0x0f, 0x84, 0x4b, 0xff, 0xff, 0xff, //0x000000df je LBB0_2
0x81, 0xe7, 0x03, 0x30, 0x00, 0x00, //0x000000e5 andl $12291, %edi
0x0f, 0x84, 0x3f, 0xff, 0xff, 0xff, //0x000000eb je LBB0_2
//0x000000f1 LBB0_13
0x48, 0xf7, 0xd0, //0x000000f1 notq %rax
0x4c, 0x01, 0xd0, //0x000000f4 addq %r10, %rax
0x48, 0x83, 0xc4, 0x08, //0x000000f7 addq $8, %rsp
0x5b, //0x000000fb popq %rbx
0x5d, //0x000000fc popq %rbp
0xc3, //0x000000fd retq
//0x000000fe LBB0_14
0x4d, 0x01, 0xd3, //0x000000fe addq %r10, %r11
0x4c, 0x39, 0xd8, //0x00000101 cmpq %r11, %rax
0x0f, 0x83, 0x03, 0x01, 0x00, 0x00, //0x00000104 jae LBB0_30
0x4c, 0x8d, 0x45, 0xf4, //0x0000010a leaq $-12(%rbp), %r8
0x4c, 0x8d, 0x4d, 0xf2, //0x0000010e leaq $-14(%rbp), %r9
0xe9, 0x16, 0x00, 0x00, 0x00, //0x00000112 jmp LBB0_17
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000117 .p2align 4, 0x90
//0x00000120 LBB0_16
0x48, 0x83, 0xc0, 0x01, //0x00000120 addq $1, %rax
0x4c, 0x39, 0xd8, //0x00000124 cmpq %r11, %rax
0x0f, 0x83, 0xe0, 0x00, 0x00, 0x00, //0x00000127 jae LBB0_30
//0x0000012d LBB0_17
0x80, 0x38, 0x00, //0x0000012d cmpb $0, (%rax)
0x0f, 0x89, 0xea, 0xff, 0xff, 0xff, //0x00000130 jns LBB0_16
0xc6, 0x45, 0xf4, 0x00, //0x00000136 movb $0, $-12(%rbp)
0xc6, 0x45, 0xf2, 0x00, //0x0000013a movb $0, $-14(%rbp)
0x4c, 0x89, 0xda, //0x0000013e movq %r11, %rdx
0x48, 0x29, 0xc2, //0x00000141 subq %rax, %rdx
0x48, 0x83, 0xfa, 0x02, //0x00000144 cmpq $2, %rdx
0x0f, 0x82, 0x31, 0x00, 0x00, 0x00, //0x00000148 jb LBB0_21
0x0f, 0xb6, 0x30, //0x0000014e movzbl (%rax), %esi
0x0f, 0xb6, 0x78, 0x01, //0x00000151 movzbl $1(%rax), %edi
0x40, 0x88, 0x75, 0xf4, //0x00000155 movb %sil, $-12(%rbp)
0x48, 0x8d, 0x48, 0x02, //0x00000159 leaq $2(%rax), %rcx
0x48, 0x83, 0xc2, 0xfe, //0x0000015d addq $-2, %rdx
0x4c, 0x89, 0xcb, //0x00000161 movq %r9, %rbx
0x48, 0x85, 0xd2, //0x00000164 testq %rdx, %rdx
0x0f, 0x84, 0x25, 0x00, 0x00, 0x00, //0x00000167 je LBB0_22
//0x0000016d LBB0_20
0x0f, 0xb6, 0x09, //0x0000016d movzbl (%rcx), %ecx
0x88, 0x0b, //0x00000170 movb %cl, (%rbx)
0x0f, 0xb6, 0x75, 0xf4, //0x00000172 movzbl $-12(%rbp), %esi
0x0f, 0xb6, 0x4d, 0xf2, //0x00000176 movzbl $-14(%rbp), %ecx
0xe9, 0x15, 0x00, 0x00, 0x00, //0x0000017a jmp LBB0_23
//0x0000017f LBB0_21
0x31, 0xf6, //0x0000017f xorl %esi, %esi
0x31, 0xff, //0x00000181 xorl %edi, %edi
0x4c, 0x89, 0xc3, //0x00000183 movq %r8, %rbx
0x48, 0x89, 0xc1, //0x00000186 movq %rax, %rcx
0x48, 0x85, 0xd2, //0x00000189 testq %rdx, %rdx
0x0f, 0x85, 0xdb, 0xff, 0xff, 0xff, //0x0000018c jne LBB0_20
//0x00000192 LBB0_22
0x31, 0xc9, //0x00000192 xorl %ecx, %ecx
//0x00000194 LBB0_23
0x0f, 0xb6, 0xc9, //0x00000194 movzbl %cl, %ecx
0xc1, 0xe1, 0x10, //0x00000197 shll $16, %ecx
0x40, 0x0f, 0xb6, 0xff, //0x0000019a movzbl %dil, %edi
0xc1, 0xe7, 0x08, //0x0000019e shll $8, %edi
0x09, 0xcf, //0x000001a1 orl %ecx, %edi
0x40, 0x0f, 0xb6, 0xd6, //0x000001a3 movzbl %sil, %edx
0x09, 0xfa, //0x000001a7 orl %edi, %edx
0x89, 0xd1, //0x000001a9 movl %edx, %ecx
0x81, 0xe1, 0xf0, 0xc0, 0xc0, 0x00, //0x000001ab andl $12632304, %ecx
0x81, 0xf9, 0xe0, 0x80, 0x80, 0x00, //0x000001b1 cmpl $8421600, %ecx
0x0f, 0x85, 0x23, 0x00, 0x00, 0x00, //0x000001b7 jne LBB0_26
0x89, 0xd7, //0x000001bd movl %edx, %edi
0x81, 0xe7, 0x0f, 0x20, 0x00, 0x00, //0x000001bf andl $8207, %edi
0x81, 0xff, 0x0d, 0x20, 0x00, 0x00, //0x000001c5 cmpl $8205, %edi
0x0f, 0x84, 0x0f, 0x00, 0x00, 0x00, //0x000001cb je LBB0_26
0xb9, 0x03, 0x00, 0x00, 0x00, //0x000001d1 movl $3, %ecx
0x85, 0xff, //0x000001d6 testl %edi, %edi
0x0f, 0x85, 0x23, 0x00, 0x00, 0x00, //0x000001d8 jne LBB0_28
0x90, 0x90, //0x000001de .p2align 4, 0x90
//0x000001e0 LBB0_26
0x40, 0xf6, 0xc6, 0x1e, //0x000001e0 testb $30, %sil
0x0f, 0x84, 0x07, 0xff, 0xff, 0xff, //0x000001e4 je LBB0_13
0x81, 0xe2, 0xe0, 0xc0, 0x00, 0x00, //0x000001ea andl $49376, %edx
0xb9, 0x02, 0x00, 0x00, 0x00, //0x000001f0 movl $2, %ecx
0x81, 0xfa, 0xc0, 0x80, 0x00, 0x00, //0x000001f5 cmpl $32960, %edx
0x0f, 0x85, 0xf0, 0xfe, 0xff, 0xff, //0x000001fb jne LBB0_13
//0x00000201 LBB0_28
0x48, 0x01, 0xc8, //0x00000201 addq %rcx, %rax
0x4c, 0x39, 0xd8, //0x00000204 cmpq %r11, %rax
0x0f, 0x82, 0x20, 0xff, 0xff, 0xff, //0x00000207 jb LBB0_17
//0x0000020d LBB0_30
0x31, 0xc0, //0x0000020d xorl %eax, %eax
0x48, 0x83, 0xc4, 0x08, //0x0000020f addq $8, %rsp
0x5b, //0x00000213 popq %rbx
0x5d, //0x00000214 popq %rbp
0xc3, //0x00000215 retq
0x00, 0x00, //0x00000216 .p2align 2, 0x00
//0x00000218 _MASK_USE_NUMBER
0x02, 0x00, 0x00, 0x00, //0x00000218 .long 2
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/skip_array_text_amd64.go | vendor/github.com/bytedance/sonic/internal/native/sse/skip_array_text_amd64.go | // +build amd64
// Code generated by asm2asm, DO NOT EDIT.
package sse
var _text_skip_array = []byte{
// .p2align 4, 0x00
// LCPI0_0
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // .quad 1
0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000008 .quad 5
//0x00000010 LCPI0_1
0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, //0x00000010 QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""'
//0x00000020 LCPI0_2
0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, //0x00000020 QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
//0x00000030 LCPI0_3
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, //0x00000030 QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' '
//0x00000040 LCPI0_4
0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, //0x00000040 QUAD $0x7b7b7b7b7b7b7b7b; QUAD $0x7b7b7b7b7b7b7b7b // .space 16, '{{{{{{{{{{{{{{{{'
//0x00000050 LCPI0_5
0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, //0x00000050 QUAD $0x7d7d7d7d7d7d7d7d; QUAD $0x7d7d7d7d7d7d7d7d // .space 16, '}}}}}}}}}}}}}}}}'
//0x00000060 LCPI0_6
0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, //0x00000060 QUAD $0x5b5b5b5b5b5b5b5b; QUAD $0x5b5b5b5b5b5b5b5b // .space 16, '[[[[[[[[[[[[[[[['
//0x00000070 LCPI0_7
0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, //0x00000070 QUAD $0x5d5d5d5d5d5d5d5d; QUAD $0x5d5d5d5d5d5d5d5d // .space 16, ']]]]]]]]]]]]]]]]'
//0x00000080 LCPI0_8
0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, //0x00000080 QUAD $0x2c2c2c2c2c2c2c2c; QUAD $0x2c2c2c2c2c2c2c2c // .space 16, ',,,,,,,,,,,,,,,,'
//0x00000090 LCPI0_9
0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, //0x00000090 QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf'
//0x000000a0 LCPI0_10
0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, //0x000000a0 QUAD $0x2f2f2f2f2f2f2f2f; QUAD $0x2f2f2f2f2f2f2f2f // .space 16, '////////////////'
//0x000000b0 LCPI0_11
0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, //0x000000b0 QUAD $0x3a3a3a3a3a3a3a3a; QUAD $0x3a3a3a3a3a3a3a3a // .space 16, '::::::::::::::::'
//0x000000c0 LCPI0_12
0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, //0x000000c0 QUAD $0x2b2b2b2b2b2b2b2b; QUAD $0x2b2b2b2b2b2b2b2b // .space 16, '++++++++++++++++'
//0x000000d0 LCPI0_13
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, //0x000000d0 QUAD $0x2d2d2d2d2d2d2d2d; QUAD $0x2d2d2d2d2d2d2d2d // .space 16, '----------------'
//0x000000e0 LCPI0_14
0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, //0x000000e0 QUAD $0x2e2e2e2e2e2e2e2e; QUAD $0x2e2e2e2e2e2e2e2e // .space 16, '................'
//0x000000f0 LCPI0_15
0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, //0x000000f0 QUAD $0x4545454545454545; QUAD $0x4545454545454545 // .space 16, 'EEEEEEEEEEEEEEEE'
//0x00000100 .p2align 4, 0x90
//0x00000100 _skip_array
0x55, //0x00000100 pushq %rbp
0x48, 0x89, 0xe5, //0x00000101 movq %rsp, %rbp
0x41, 0x57, //0x00000104 pushq %r15
0x41, 0x56, //0x00000106 pushq %r14
0x41, 0x55, //0x00000108 pushq %r13
0x41, 0x54, //0x0000010a pushq %r12
0x53, //0x0000010c pushq %rbx
0x48, 0x81, 0xec, 0x88, 0x00, 0x00, 0x00, //0x0000010d subq $136, %rsp
0x48, 0x89, 0x4d, 0x98, //0x00000114 movq %rcx, $-104(%rbp)
0x49, 0x89, 0xd5, //0x00000118 movq %rdx, %r13
0x49, 0x89, 0xf6, //0x0000011b movq %rsi, %r14
0x48, 0x89, 0x7d, 0xa8, //0x0000011e movq %rdi, $-88(%rbp)
0x0f, 0x10, 0x05, 0xd7, 0xfe, 0xff, 0xff, //0x00000122 movups $-297(%rip), %xmm0 /* LCPI0_0+0(%rip) */
0x0f, 0x11, 0x02, //0x00000129 movups %xmm0, (%rdx)
0x48, 0xc7, 0xc1, 0xff, 0xff, 0xff, 0xff, //0x0000012c movq $-1, %rcx
0x49, 0xbb, 0x00, 0x26, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, //0x00000133 movabsq $4294977024, %r11
0xf3, 0x0f, 0x6f, 0x05, 0xcb, 0xfe, 0xff, 0xff, //0x0000013d movdqu $-309(%rip), %xmm0 /* LCPI0_1+0(%rip) */
0xf3, 0x0f, 0x6f, 0x0d, 0xd3, 0xfe, 0xff, 0xff, //0x00000145 movdqu $-301(%rip), %xmm1 /* LCPI0_2+0(%rip) */
0xf3, 0x44, 0x0f, 0x6f, 0x25, 0xda, 0xfe, 0xff, 0xff, //0x0000014d movdqu $-294(%rip), %xmm12 /* LCPI0_3+0(%rip) */
0x66, 0x45, 0x0f, 0x76, 0xd2, //0x00000156 pcmpeqd %xmm10, %xmm10
0xf3, 0x44, 0x0f, 0x6f, 0x3d, 0x4c, 0xff, 0xff, 0xff, //0x0000015b movdqu $-180(%rip), %xmm15 /* LCPI0_11+0(%rip) */
0xf3, 0x44, 0x0f, 0x6f, 0x0d, 0x23, 0xff, 0xff, 0xff, //0x00000164 movdqu $-221(%rip), %xmm9 /* LCPI0_9+0(%rip) */
0xf3, 0x44, 0x0f, 0x6f, 0x1d, 0x7a, 0xff, 0xff, 0xff, //0x0000016d movdqu $-134(%rip), %xmm11 /* LCPI0_15+0(%rip) */
0xf3, 0x44, 0x0f, 0x6f, 0x35, 0x01, 0xff, 0xff, 0xff, //0x00000176 movdqu $-255(%rip), %xmm14 /* LCPI0_8+0(%rip) */
0xf3, 0x0f, 0x6f, 0x15, 0xe9, 0xfe, 0xff, 0xff, //0x0000017f movdqu $-279(%rip), %xmm2 /* LCPI0_7+0(%rip) */
0xf3, 0x44, 0x0f, 0x6f, 0x2d, 0xb0, 0xfe, 0xff, 0xff, //0x00000187 movdqu $-336(%rip), %xmm13 /* LCPI0_4+0(%rip) */
0xf3, 0x44, 0x0f, 0x6f, 0x05, 0xb7, 0xfe, 0xff, 0xff, //0x00000190 movdqu $-329(%rip), %xmm8 /* LCPI0_5+0(%rip) */
0x48, 0x89, 0x75, 0xd0, //0x00000199 movq %rsi, $-48(%rbp)
0x48, 0x89, 0x55, 0xb8, //0x0000019d movq %rdx, $-72(%rbp)
0xe9, 0x7a, 0x00, 0x00, 0x00, //0x000001a1 jmp LBB0_6
//0x000001a6 LBB0_613
0x66, 0x0f, 0xbc, 0xc2, //0x000001a6 bsfw %dx, %ax
0x0f, 0xb7, 0xc0, //0x000001aa movzwl %ax, %eax
0x48, 0x29, 0xc8, //0x000001ad subq %rcx, %rax
0x49, 0x89, 0x06, //0x000001b0 movq %rax, (%r14)
0x48, 0x85, 0xf6, //0x000001b3 testq %rsi, %rsi
0x0f, 0x8e, 0x9d, 0x38, 0x00, 0x00, //0x000001b6 jle LBB0_614
0x90, 0x90, 0x90, 0x90, //0x000001bc .p2align 4, 0x90
//0x000001c0 LBB0_4
0x4d, 0x8b, 0x45, 0x00, //0x000001c0 movq (%r13), %r8
0x48, 0x8b, 0x75, 0x90, //0x000001c4 movq $-112(%rbp), %rsi
0x48, 0x89, 0xf1, //0x000001c8 movq %rsi, %rcx
0x48, 0x89, 0xf0, //0x000001cb movq %rsi, %rax
0x4d, 0x85, 0xc0, //0x000001ce testq %r8, %r8
0x0f, 0x85, 0x49, 0x00, 0x00, 0x00, //0x000001d1 jne LBB0_6
0xe9, 0x6b, 0x38, 0x00, 0x00, //0x000001d7 jmp LBB0_638
//0x000001dc LBB0_1
0x49, 0xf7, 0xdb, //0x000001dc negq %r11
0x4d, 0x89, 0xdd, //0x000001df movq %r11, %r13
//0x000001e2 LBB0_2
0x4d, 0x85, 0xed, //0x000001e2 testq %r13, %r13
0x0f, 0x88, 0x47, 0x38, 0x00, 0x00, //0x000001e5 js LBB0_612
//0x000001eb LBB0_3
0x49, 0x01, 0xc5, //0x000001eb addq %rax, %r13
0x4c, 0x8b, 0x75, 0xd0, //0x000001ee movq $-48(%rbp), %r14
0x4d, 0x89, 0x2e, //0x000001f2 movq %r13, (%r14)
0x48, 0x85, 0xc0, //0x000001f5 testq %rax, %rax
0x4c, 0x8b, 0x6d, 0xb8, //0x000001f8 movq $-72(%rbp), %r13
0x49, 0xbb, 0x00, 0x26, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, //0x000001fc movabsq $4294977024, %r11
0x0f, 0x89, 0xb4, 0xff, 0xff, 0xff, //0x00000206 jns LBB0_4
0xe9, 0x36, 0x38, 0x00, 0x00, //0x0000020c jmp LBB0_638
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000211 .p2align 4, 0x90
//0x00000220 LBB0_6
0x48, 0x8b, 0x45, 0xa8, //0x00000220 movq $-88(%rbp), %rax
0x4c, 0x8b, 0x20, //0x00000224 movq (%rax), %r12
0x48, 0x8b, 0x40, 0x08, //0x00000227 movq $8(%rax), %rax
0x49, 0x8b, 0x16, //0x0000022b movq (%r14), %rdx
0x48, 0x39, 0xc2, //0x0000022e cmpq %rax, %rdx
0x0f, 0x83, 0x39, 0x00, 0x00, 0x00, //0x00000231 jae LBB0_11
0x41, 0x8a, 0x1c, 0x14, //0x00000237 movb (%r12,%rdx), %bl
0x80, 0xfb, 0x0d, //0x0000023b cmpb $13, %bl
0x0f, 0x84, 0x2c, 0x00, 0x00, 0x00, //0x0000023e je LBB0_11
0x80, 0xfb, 0x20, //0x00000244 cmpb $32, %bl
0x0f, 0x84, 0x23, 0x00, 0x00, 0x00, //0x00000247 je LBB0_11
0x80, 0xc3, 0xf7, //0x0000024d addb $-9, %bl
0x80, 0xfb, 0x01, //0x00000250 cmpb $1, %bl
0x0f, 0x86, 0x17, 0x00, 0x00, 0x00, //0x00000253 jbe LBB0_11
0x48, 0x89, 0xd6, //0x00000259 movq %rdx, %rsi
0xe9, 0x07, 0x01, 0x00, 0x00, //0x0000025c jmp LBB0_32
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000261 .p2align 4, 0x90
//0x00000270 LBB0_11
0x48, 0x8d, 0x72, 0x01, //0x00000270 leaq $1(%rdx), %rsi
0x48, 0x39, 0xc6, //0x00000274 cmpq %rax, %rsi
0x0f, 0x83, 0x23, 0x00, 0x00, 0x00, //0x00000277 jae LBB0_15
0x41, 0x8a, 0x1c, 0x34, //0x0000027d movb (%r12,%rsi), %bl
0x80, 0xfb, 0x0d, //0x00000281 cmpb $13, %bl
0x0f, 0x84, 0x16, 0x00, 0x00, 0x00, //0x00000284 je LBB0_15
0x80, 0xfb, 0x20, //0x0000028a cmpb $32, %bl
0x0f, 0x84, 0x0d, 0x00, 0x00, 0x00, //0x0000028d je LBB0_15
0x80, 0xc3, 0xf7, //0x00000293 addb $-9, %bl
0x80, 0xfb, 0x01, //0x00000296 cmpb $1, %bl
0x0f, 0x87, 0xc9, 0x00, 0x00, 0x00, //0x00000299 ja LBB0_32
0x90, //0x0000029f .p2align 4, 0x90
//0x000002a0 LBB0_15
0x48, 0x8d, 0x72, 0x02, //0x000002a0 leaq $2(%rdx), %rsi
0x48, 0x39, 0xc6, //0x000002a4 cmpq %rax, %rsi
0x0f, 0x83, 0x23, 0x00, 0x00, 0x00, //0x000002a7 jae LBB0_19
0x41, 0x8a, 0x1c, 0x34, //0x000002ad movb (%r12,%rsi), %bl
0x80, 0xfb, 0x0d, //0x000002b1 cmpb $13, %bl
0x0f, 0x84, 0x16, 0x00, 0x00, 0x00, //0x000002b4 je LBB0_19
0x80, 0xfb, 0x20, //0x000002ba cmpb $32, %bl
0x0f, 0x84, 0x0d, 0x00, 0x00, 0x00, //0x000002bd je LBB0_19
0x80, 0xc3, 0xf7, //0x000002c3 addb $-9, %bl
0x80, 0xfb, 0x01, //0x000002c6 cmpb $1, %bl
0x0f, 0x87, 0x99, 0x00, 0x00, 0x00, //0x000002c9 ja LBB0_32
0x90, //0x000002cf .p2align 4, 0x90
//0x000002d0 LBB0_19
0x48, 0x8d, 0x72, 0x03, //0x000002d0 leaq $3(%rdx), %rsi
0x48, 0x39, 0xc6, //0x000002d4 cmpq %rax, %rsi
0x0f, 0x83, 0x23, 0x00, 0x00, 0x00, //0x000002d7 jae LBB0_23
0x41, 0x8a, 0x1c, 0x34, //0x000002dd movb (%r12,%rsi), %bl
0x80, 0xfb, 0x0d, //0x000002e1 cmpb $13, %bl
0x0f, 0x84, 0x16, 0x00, 0x00, 0x00, //0x000002e4 je LBB0_23
0x80, 0xfb, 0x20, //0x000002ea cmpb $32, %bl
0x0f, 0x84, 0x0d, 0x00, 0x00, 0x00, //0x000002ed je LBB0_23
0x80, 0xc3, 0xf7, //0x000002f3 addb $-9, %bl
0x80, 0xfb, 0x01, //0x000002f6 cmpb $1, %bl
0x0f, 0x87, 0x69, 0x00, 0x00, 0x00, //0x000002f9 ja LBB0_32
0x90, //0x000002ff .p2align 4, 0x90
//0x00000300 LBB0_23
0x48, 0x83, 0xc2, 0x04, //0x00000300 addq $4, %rdx
0x48, 0x39, 0xd0, //0x00000304 cmpq %rdx, %rax
0x0f, 0x86, 0xd0, 0x36, 0x00, 0x00, //0x00000307 jbe LBB0_603
0x48, 0x39, 0xd0, //0x0000030d cmpq %rdx, %rax
0x0f, 0x84, 0x3a, 0x00, 0x00, 0x00, //0x00000310 je LBB0_29
0x49, 0x8d, 0x34, 0x04, //0x00000316 leaq (%r12,%rax), %rsi
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x0000031a .p2align 4, 0x90
//0x00000320 LBB0_26
0x41, 0x0f, 0xbe, 0x3c, 0x14, //0x00000320 movsbl (%r12,%rdx), %edi
0x83, 0xff, 0x20, //0x00000325 cmpl $32, %edi
0x0f, 0x87, 0x2e, 0x00, 0x00, 0x00, //0x00000328 ja LBB0_31
0x49, 0x0f, 0xa3, 0xfb, //0x0000032e btq %rdi, %r11
0x0f, 0x83, 0x24, 0x00, 0x00, 0x00, //0x00000332 jae LBB0_31
0x48, 0x83, 0xc2, 0x01, //0x00000338 addq $1, %rdx
0x48, 0x39, 0xd0, //0x0000033c cmpq %rdx, %rax
0x0f, 0x85, 0xdb, 0xff, 0xff, 0xff, //0x0000033f jne LBB0_26
0xe9, 0x0c, 0x00, 0x00, 0x00, //0x00000345 jmp LBB0_30
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x0000034a .p2align 4, 0x90
//0x00000350 LBB0_29
0x4c, 0x01, 0xe2, //0x00000350 addq %r12, %rdx
0x48, 0x89, 0xd6, //0x00000353 movq %rdx, %rsi
//0x00000356 LBB0_30
0x4c, 0x29, 0xe6, //0x00000356 subq %r12, %rsi
0x48, 0x89, 0xf2, //0x00000359 movq %rsi, %rdx
//0x0000035c LBB0_31
0x48, 0x89, 0xd6, //0x0000035c movq %rdx, %rsi
0x48, 0x39, 0xc2, //0x0000035f cmpq %rax, %rdx
0x0f, 0x83, 0x78, 0x36, 0x00, 0x00, //0x00000362 jae LBB0_604
//0x00000368 LBB0_32
0x48, 0x8d, 0x46, 0x01, //0x00000368 leaq $1(%rsi), %rax
0x49, 0x89, 0x06, //0x0000036c movq %rax, (%r14)
0x41, 0x0f, 0xbe, 0x3c, 0x34, //0x0000036f movsbl (%r12,%rsi), %edi
0x48, 0xc7, 0xc0, 0xff, 0xff, 0xff, 0xff, //0x00000374 movq $-1, %rax
0x85, 0xff, //0x0000037b testl %edi, %edi
0x0f, 0x84, 0xc4, 0x36, 0x00, 0x00, //0x0000037d je LBB0_638
0x4d, 0x8b, 0x4d, 0x00, //0x00000383 movq (%r13), %r9
0x4d, 0x8d, 0x41, 0xff, //0x00000387 leaq $-1(%r9), %r8
0x43, 0x8b, 0x5c, 0xcd, 0x00, //0x0000038b movl (%r13,%r9,8), %ebx
0x48, 0x83, 0xf9, 0xff, //0x00000390 cmpq $-1, %rcx
0x48, 0x0f, 0x45, 0xf1, //0x00000394 cmovneq %rcx, %rsi
0x83, 0xc3, 0xff, //0x00000398 addl $-1, %ebx
0x83, 0xfb, 0x05, //0x0000039b cmpl $5, %ebx
0x0f, 0x87, 0x82, 0x02, 0x00, 0x00, //0x0000039e ja LBB0_78
0x48, 0x8d, 0x15, 0x35, 0x39, 0x00, 0x00, //0x000003a4 leaq $14645(%rip), %rdx /* LJTI0_0+0(%rip) */
0x48, 0x63, 0x0c, 0x9a, //0x000003ab movslq (%rdx,%rbx,4), %rcx
0x48, 0x01, 0xd1, //0x000003af addq %rdx, %rcx
0xff, 0xe1, //0x000003b2 jmpq *%rcx
//0x000003b4 LBB0_35
0x83, 0xff, 0x2c, //0x000003b4 cmpl $44, %edi
0x0f, 0x84, 0xec, 0x04, 0x00, 0x00, //0x000003b7 je LBB0_117
0x83, 0xff, 0x5d, //0x000003bd cmpl $93, %edi
0x0f, 0x84, 0x48, 0x02, 0x00, 0x00, //0x000003c0 je LBB0_37
0xe9, 0x75, 0x36, 0x00, 0x00, //0x000003c6 jmp LBB0_637
//0x000003cb LBB0_38
0x40, 0x80, 0xff, 0x5d, //0x000003cb cmpb $93, %dil
0x0f, 0x84, 0x39, 0x02, 0x00, 0x00, //0x000003cf je LBB0_37
0x48, 0x89, 0x75, 0x90, //0x000003d5 movq %rsi, $-112(%rbp)
0x4b, 0xc7, 0x44, 0xcd, 0x00, 0x01, 0x00, 0x00, 0x00, //0x000003d9 movq $1, (%r13,%r9,8)
0x83, 0xff, 0x7b, //0x000003e2 cmpl $123, %edi
0x0f, 0x86, 0x4c, 0x02, 0x00, 0x00, //0x000003e5 jbe LBB0_79
0xe9, 0x50, 0x36, 0x00, 0x00, //0x000003eb jmp LBB0_637
//0x000003f0 LBB0_40
0x40, 0x80, 0xff, 0x22, //0x000003f0 cmpb $34, %dil
0x0f, 0x85, 0x46, 0x36, 0x00, 0x00, //0x000003f4 jne LBB0_637
0x4b, 0xc7, 0x44, 0xcd, 0x00, 0x04, 0x00, 0x00, 0x00, //0x000003fa movq $4, (%r13,%r9,8)
0x48, 0x8b, 0x4d, 0x98, //0x00000403 movq $-104(%rbp), %rcx
0xf6, 0xc1, 0x40, //0x00000407 testb $64, %cl
0x48, 0x89, 0x75, 0x90, //0x0000040a movq %rsi, $-112(%rbp)
0x0f, 0x85, 0x7c, 0x06, 0x00, 0x00, //0x0000040e jne LBB0_125
0x49, 0x8b, 0x16, //0x00000414 movq (%r14), %rdx
0x48, 0x8b, 0x45, 0xa8, //0x00000417 movq $-88(%rbp), %rax
0x48, 0x8b, 0x40, 0x08, //0x0000041b movq $8(%rax), %rax
0xf6, 0xc1, 0x20, //0x0000041f testb $32, %cl
0x48, 0x89, 0x45, 0xa0, //0x00000422 movq %rax, $-96(%rbp)
0x48, 0x89, 0x55, 0xb0, //0x00000426 movq %rdx, $-80(%rbp)
0x0f, 0x85, 0x5e, 0x09, 0x00, 0x00, //0x0000042a jne LBB0_157
0x49, 0x89, 0xc1, //0x00000430 movq %rax, %r9
0x49, 0x29, 0xd1, //0x00000433 subq %rdx, %r9
0x0f, 0x84, 0xc2, 0x37, 0x00, 0x00, //0x00000436 je LBB0_642
0x49, 0x83, 0xf9, 0x40, //0x0000043c cmpq $64, %r9
0x0f, 0x82, 0x4a, 0x2a, 0x00, 0x00, //0x00000440 jb LBB0_484
0x48, 0x8b, 0x45, 0xb0, //0x00000446 movq $-80(%rbp), %rax
0x49, 0x89, 0xc6, //0x0000044a movq %rax, %r14
0x49, 0xf7, 0xd6, //0x0000044d notq %r14
0x48, 0xc7, 0x45, 0xc8, 0xff, 0xff, 0xff, 0xff, //0x00000450 movq $-1, $-56(%rbp)
0x45, 0x31, 0xc0, //0x00000458 xorl %r8d, %r8d
0x90, 0x90, 0x90, 0x90, 0x90, //0x0000045b .p2align 4, 0x90
//0x00000460 LBB0_46
0xf3, 0x41, 0x0f, 0x6f, 0x1c, 0x04, //0x00000460 movdqu (%r12,%rax), %xmm3
0xf3, 0x41, 0x0f, 0x6f, 0x64, 0x04, 0x10, //0x00000466 movdqu $16(%r12,%rax), %xmm4
0xf3, 0x41, 0x0f, 0x6f, 0x6c, 0x04, 0x20, //0x0000046d movdqu $32(%r12,%rax), %xmm5
0xf3, 0x41, 0x0f, 0x6f, 0x74, 0x04, 0x30, //0x00000474 movdqu $48(%r12,%rax), %xmm6
0x66, 0x0f, 0x6f, 0xfb, //0x0000047b movdqa %xmm3, %xmm7
0x66, 0x0f, 0x74, 0xf8, //0x0000047f pcmpeqb %xmm0, %xmm7
0x66, 0x44, 0x0f, 0xd7, 0xd7, //0x00000483 pmovmskb %xmm7, %r10d
0x66, 0x0f, 0x6f, 0xfc, //0x00000488 movdqa %xmm4, %xmm7
0x66, 0x0f, 0x74, 0xf8, //0x0000048c pcmpeqb %xmm0, %xmm7
0x66, 0x0f, 0xd7, 0xdf, //0x00000490 pmovmskb %xmm7, %ebx
0x66, 0x0f, 0x6f, 0xfd, //0x00000494 movdqa %xmm5, %xmm7
0x66, 0x0f, 0x74, 0xf8, //0x00000498 pcmpeqb %xmm0, %xmm7
0x66, 0x0f, 0xd7, 0xff, //0x0000049c pmovmskb %xmm7, %edi
0x66, 0x0f, 0x6f, 0xfe, //0x000004a0 movdqa %xmm6, %xmm7
0x66, 0x0f, 0x74, 0xf8, //0x000004a4 pcmpeqb %xmm0, %xmm7
0x66, 0x0f, 0xd7, 0xd7, //0x000004a8 pmovmskb %xmm7, %edx
0x66, 0x0f, 0x74, 0xd9, //0x000004ac pcmpeqb %xmm1, %xmm3
0x66, 0x44, 0x0f, 0xd7, 0xdb, //0x000004b0 pmovmskb %xmm3, %r11d
0x66, 0x0f, 0x74, 0xe1, //0x000004b5 pcmpeqb %xmm1, %xmm4
0x66, 0x0f, 0xd7, 0xcc, //0x000004b9 pmovmskb %xmm4, %ecx
0x66, 0x0f, 0x74, 0xe9, //0x000004bd pcmpeqb %xmm1, %xmm5
0x66, 0x0f, 0xd7, 0xf5, //0x000004c1 pmovmskb %xmm5, %esi
0x66, 0x0f, 0x74, 0xf1, //0x000004c5 pcmpeqb %xmm1, %xmm6
0x66, 0x44, 0x0f, 0xd7, 0xfe, //0x000004c9 pmovmskb %xmm6, %r15d
0x48, 0xc1, 0xe2, 0x30, //0x000004ce shlq $48, %rdx
0x48, 0xc1, 0xe7, 0x20, //0x000004d2 shlq $32, %rdi
0x48, 0x09, 0xd7, //0x000004d6 orq %rdx, %rdi
0x48, 0xc1, 0xe3, 0x10, //0x000004d9 shlq $16, %rbx
0x48, 0x09, 0xfb, //0x000004dd orq %rdi, %rbx
0x49, 0x09, 0xda, //0x000004e0 orq %rbx, %r10
0x49, 0xc1, 0xe7, 0x30, //0x000004e3 shlq $48, %r15
0x48, 0xc1, 0xe6, 0x20, //0x000004e7 shlq $32, %rsi
0x4c, 0x09, 0xfe, //0x000004eb orq %r15, %rsi
0x48, 0xc1, 0xe1, 0x10, //0x000004ee shlq $16, %rcx
0x48, 0x09, 0xf1, //0x000004f2 orq %rsi, %rcx
0x49, 0x09, 0xcb, //0x000004f5 orq %rcx, %r11
0x0f, 0x85, 0x30, 0x00, 0x00, 0x00, //0x000004f8 jne LBB0_55
0x4d, 0x85, 0xc0, //0x000004fe testq %r8, %r8
0x0f, 0x85, 0x3d, 0x00, 0x00, 0x00, //0x00000501 jne LBB0_57
0x45, 0x31, 0xc0, //0x00000507 xorl %r8d, %r8d
0x4d, 0x85, 0xd2, //0x0000050a testq %r10, %r10
0x0f, 0x85, 0x83, 0x00, 0x00, 0x00, //0x0000050d jne LBB0_58
//0x00000513 LBB0_49
0x49, 0x83, 0xc1, 0xc0, //0x00000513 addq $-64, %r9
0x49, 0x83, 0xc6, 0xc0, //0x00000517 addq $-64, %r14
0x48, 0x83, 0xc0, 0x40, //0x0000051b addq $64, %rax
0x49, 0x83, 0xf9, 0x3f, //0x0000051f cmpq $63, %r9
0x0f, 0x87, 0x37, 0xff, 0xff, 0xff, //0x00000523 ja LBB0_46
0xe9, 0xce, 0x21, 0x00, 0x00, //0x00000529 jmp LBB0_50
//0x0000052e LBB0_55
0x48, 0x83, 0x7d, 0xc8, 0xff, //0x0000052e cmpq $-1, $-56(%rbp)
0x0f, 0x85, 0x0b, 0x00, 0x00, 0x00, //0x00000533 jne LBB0_57
0x49, 0x0f, 0xbc, 0xcb, //0x00000539 bsfq %r11, %rcx
0x48, 0x01, 0xc1, //0x0000053d addq %rax, %rcx
0x48, 0x89, 0x4d, 0xc8, //0x00000540 movq %rcx, $-56(%rbp)
//0x00000544 LBB0_57
0x4c, 0x89, 0xc1, //0x00000544 movq %r8, %rcx
0x48, 0xf7, 0xd1, //0x00000547 notq %rcx
0x4c, 0x21, 0xd9, //0x0000054a andq %r11, %rcx
0x48, 0x8d, 0x14, 0x09, //0x0000054d leaq (%rcx,%rcx), %rdx
0x4c, 0x09, 0xc2, //0x00000551 orq %r8, %rdx
0x48, 0x89, 0xd6, //0x00000554 movq %rdx, %rsi
0x48, 0xf7, 0xd6, //0x00000557 notq %rsi
0x4c, 0x21, 0xde, //0x0000055a andq %r11, %rsi
0x48, 0xbf, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, //0x0000055d movabsq $-6148914691236517206, %rdi
0x48, 0x21, 0xfe, //0x00000567 andq %rdi, %rsi
0x45, 0x31, 0xc0, //0x0000056a xorl %r8d, %r8d
0x48, 0x01, 0xce, //0x0000056d addq %rcx, %rsi
0x41, 0x0f, 0x92, 0xc0, //0x00000570 setb %r8b
0x48, 0x01, 0xf6, //0x00000574 addq %rsi, %rsi
0x48, 0xb9, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, //0x00000577 movabsq $6148914691236517205, %rcx
0x48, 0x31, 0xce, //0x00000581 xorq %rcx, %rsi
0x48, 0x21, 0xd6, //0x00000584 andq %rdx, %rsi
0x48, 0xf7, 0xd6, //0x00000587 notq %rsi
0x49, 0x21, 0xf2, //0x0000058a andq %rsi, %r10
0x4d, 0x85, 0xd2, //0x0000058d testq %r10, %r10
0x0f, 0x84, 0x7d, 0xff, 0xff, 0xff, //0x00000590 je LBB0_49
//0x00000596 LBB0_58
0x49, 0x0f, 0xbc, 0xc2, //0x00000596 bsfq %r10, %rax
0x4c, 0x29, 0xf0, //0x0000059a subq %r14, %rax
0x4c, 0x8b, 0x75, 0xd0, //0x0000059d movq $-48(%rbp), %r14
0x49, 0xbb, 0x00, 0x26, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, //0x000005a1 movabsq $4294977024, %r11
0xe9, 0xd6, 0x0c, 0x00, 0x00, //0x000005ab jmp LBB0_223
//0x000005b0 LBB0_59
0x40, 0x80, 0xff, 0x3a, //0x000005b0 cmpb $58, %dil
0x0f, 0x85, 0x86, 0x34, 0x00, 0x00, //0x000005b4 jne LBB0_637
0x48, 0x89, 0x75, 0x90, //0x000005ba movq %rsi, $-112(%rbp)
0x4b, 0xc7, 0x44, 0xcd, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000005be movq $0, (%r13,%r9,8)
0xe9, 0xf4, 0xfb, 0xff, 0xff, //0x000005c7 jmp LBB0_4
//0x000005cc LBB0_61
0x83, 0xff, 0x2c, //0x000005cc cmpl $44, %edi
0x0f, 0x85, 0x30, 0x00, 0x00, 0x00, //0x000005cf jne LBB0_62
0x49, 0x81, 0xf9, 0xff, 0x0f, 0x00, 0x00, //0x000005d5 cmpq $4095, %r9
0x0f, 0x8f, 0x0a, 0x34, 0x00, 0x00, //0x000005dc jg LBB0_634
0x48, 0x89, 0x75, 0x90, //0x000005e2 movq %rsi, $-112(%rbp)
0x49, 0x8d, 0x41, 0x01, //0x000005e6 leaq $1(%r9), %rax
0x49, 0x89, 0x45, 0x00, //0x000005ea movq %rax, (%r13)
0x4b, 0xc7, 0x44, 0xcd, 0x08, 0x03, 0x00, 0x00, 0x00, //0x000005ee movq $3, $8(%r13,%r9,8)
0xe9, 0xc4, 0xfb, 0xff, 0xff, //0x000005f7 jmp LBB0_4
//0x000005fc LBB0_63
0x83, 0xff, 0x22, //0x000005fc cmpl $34, %edi
0x0f, 0x84, 0xcb, 0x02, 0x00, 0x00, //0x000005ff je LBB0_64
//0x00000605 LBB0_62
0x83, 0xff, 0x7d, //0x00000605 cmpl $125, %edi
0x0f, 0x85, 0x32, 0x34, 0x00, 0x00, //0x00000608 jne LBB0_637
//0x0000060e LBB0_37
0x4d, 0x89, 0x45, 0x00, //0x0000060e movq %r8, (%r13)
0x48, 0x89, 0xf1, //0x00000612 movq %rsi, %rcx
0x48, 0x89, 0xf0, //0x00000615 movq %rsi, %rax
0x4d, 0x85, 0xc0, //0x00000618 testq %r8, %r8
0x0f, 0x85, 0xff, 0xfb, 0xff, 0xff, //0x0000061b jne LBB0_6
0xe9, 0x21, 0x34, 0x00, 0x00, //0x00000621 jmp LBB0_638
//0x00000626 LBB0_78
0x48, 0x89, 0x75, 0x90, //0x00000626 movq %rsi, $-112(%rbp)
0x4d, 0x89, 0x45, 0x00, //0x0000062a movq %r8, (%r13)
0x83, 0xff, 0x7b, //0x0000062e cmpl $123, %edi
0x0f, 0x87, 0x09, 0x34, 0x00, 0x00, //0x00000631 ja LBB0_637
//0x00000637 LBB0_79
0x89, 0xf9, //0x00000637 movl %edi, %ecx
0x48, 0x8d, 0x15, 0xb8, 0x36, 0x00, 0x00, //0x00000639 leaq $14008(%rip), %rdx /* LJTI0_1+0(%rip) */
0x48, 0x63, 0x0c, 0x8a, //0x00000640 movslq (%rdx,%rcx,4), %rcx
0x48, 0x01, 0xd1, //0x00000644 addq %rdx, %rcx
0xff, 0xe1, //0x00000647 jmpq *%rcx
//0x00000649 LBB0_80
0x48, 0x8b, 0x45, 0xa8, //0x00000649 movq $-88(%rbp), %rax
0x48, 0x8b, 0x78, 0x08, //0x0000064d movq $8(%rax), %rdi
0x49, 0x8b, 0x36, //0x00000651 movq (%r14), %rsi
0xf6, 0x45, 0x98, 0x40, //0x00000654 testb $64, $-104(%rbp)
0x0f, 0x85, 0x40, 0x05, 0x00, 0x00, //0x00000658 jne LBB0_135
0x48, 0x8d, 0x46, 0xff, //0x0000065e leaq $-1(%rsi), %rax
0x48, 0x29, 0xc7, //0x00000662 subq %rax, %rdi
0x0f, 0x84, 0xc0, 0x33, 0x00, 0x00, //0x00000665 je LBB0_611
0x4d, 0x8d, 0x34, 0x34, //0x0000066b leaq (%r12,%rsi), %r14
0x49, 0x83, 0xc6, 0xff, //0x0000066f addq $-1, %r14
0x41, 0x80, 0x3e, 0x30, //0x00000673 cmpb $48, (%r14)
0x0f, 0x85, 0x37, 0x00, 0x00, 0x00, //0x00000677 jne LBB0_86
0x41, 0xbd, 0x01, 0x00, 0x00, 0x00, //0x0000067d movl $1, %r13d
0x48, 0x83, 0xff, 0x01, //0x00000683 cmpq $1, %rdi
0x0f, 0x84, 0x5e, 0xfb, 0xff, 0xff, //0x00000687 je LBB0_3
0x41, 0x8a, 0x0c, 0x34, //0x0000068d movb (%r12,%rsi), %cl
0x80, 0xc1, 0xd2, //0x00000691 addb $-46, %cl
0x80, 0xf9, 0x37, //0x00000694 cmpb $55, %cl
0x0f, 0x87, 0x4e, 0xfb, 0xff, 0xff, //0x00000697 ja LBB0_3
0x0f, 0xb6, 0xc9, //0x0000069d movzbl %cl, %ecx
0x48, 0xba, 0x01, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, //0x000006a0 movabsq $36028797027352577, %rdx
0x48, 0x0f, 0xa3, 0xca, //0x000006aa btq %rcx, %rdx
0x0f, 0x83, 0x37, 0xfb, 0xff, 0xff, //0x000006ae jae LBB0_3
//0x000006b4 LBB0_86
0x48, 0x89, 0x75, 0xc0, //0x000006b4 movq %rsi, $-64(%rbp)
0x48, 0x83, 0xff, 0x10, //0x000006b8 cmpq $16, %rdi
0x0f, 0x82, 0x14, 0x27, 0x00, 0x00, //0x000006bc jb LBB0_472
0x49, 0xc7, 0xc1, 0xff, 0xff, 0xff, 0xff, //0x000006c2 movq $-1, %r9
0x45, 0x31, 0xed, //0x000006c9 xorl %r13d, %r13d
0x49, 0xc7, 0xc7, 0xff, 0xff, 0xff, 0xff, //0x000006cc movq $-1, %r15
0x49, 0xc7, 0xc0, 0xff, 0xff, 0xff, 0xff, //0x000006d3 movq $-1, %r8
0x49, 0x89, 0xfa, //0x000006da movq %rdi, %r10
0x90, 0x90, 0x90, //0x000006dd .p2align 4, 0x90
//0x000006e0 LBB0_88
0xf3, 0x43, 0x0f, 0x6f, 0x1c, 0x2e, //0x000006e0 movdqu (%r14,%r13), %xmm3
0x66, 0x0f, 0x6f, 0xe3, //0x000006e6 movdqa %xmm3, %xmm4
0x66, 0x0f, 0x64, 0x25, 0xae, 0xf9, 0xff, 0xff, //0x000006ea pcmpgtb $-1618(%rip), %xmm4 /* LCPI0_10+0(%rip) */
0x66, 0x41, 0x0f, 0x6f, 0xef, //0x000006f2 movdqa %xmm15, %xmm5
0x66, 0x0f, 0x64, 0xeb, //0x000006f7 pcmpgtb %xmm3, %xmm5
0x66, 0x0f, 0xdb, 0xec, //0x000006fb pand %xmm4, %xmm5
0x66, 0x0f, 0x6f, 0xe3, //0x000006ff movdqa %xmm3, %xmm4
0x66, 0x0f, 0x74, 0x25, 0xb5, 0xf9, 0xff, 0xff, //0x00000703 pcmpeqb $-1611(%rip), %xmm4 /* LCPI0_12+0(%rip) */
0x66, 0x0f, 0x6f, 0xf3, //0x0000070b movdqa %xmm3, %xmm6
0x66, 0x0f, 0x74, 0x35, 0xb9, 0xf9, 0xff, 0xff, //0x0000070f pcmpeqb $-1607(%rip), %xmm6 /* LCPI0_13+0(%rip) */
0x66, 0x0f, 0xeb, 0xf4, //0x00000717 por %xmm4, %xmm6
0x66, 0x0f, 0x6f, 0xe3, //0x0000071b movdqa %xmm3, %xmm4
0x66, 0x41, 0x0f, 0xdb, 0xe1, //0x0000071f pand %xmm9, %xmm4
0x66, 0x0f, 0x74, 0x1d, 0xb4, 0xf9, 0xff, 0xff, //0x00000724 pcmpeqb $-1612(%rip), %xmm3 /* LCPI0_14+0(%rip) */
0x66, 0x41, 0x0f, 0x74, 0xe3, //0x0000072c pcmpeqb %xmm11, %xmm4
0x66, 0x0f, 0xd7, 0xd4, //0x00000731 pmovmskb %xmm4, %edx
0x66, 0x0f, 0xeb, 0xe3, //0x00000735 por %xmm3, %xmm4
0x66, 0x0f, 0xeb, 0xee, //0x00000739 por %xmm6, %xmm5
0x66, 0x0f, 0xeb, 0xec, //0x0000073d por %xmm4, %xmm5
0x66, 0x44, 0x0f, 0xd7, 0xdb, //0x00000741 pmovmskb %xmm3, %r11d
0x66, 0x0f, 0xd7, 0xf6, //0x00000746 pmovmskb %xmm6, %esi
0x66, 0x0f, 0xd7, 0xcd, //0x0000074a pmovmskb %xmm5, %ecx
0xf7, 0xd1, //0x0000074e notl %ecx
0x0f, 0xbc, 0xc9, //0x00000750 bsfl %ecx, %ecx
0x83, 0xf9, 0x10, //0x00000753 cmpl $16, %ecx
0x0f, 0x84, 0x12, 0x00, 0x00, 0x00, //0x00000756 je LBB0_90
0xbb, 0xff, 0xff, 0xff, 0xff, //0x0000075c movl $-1, %ebx
0xd3, 0xe3, //0x00000761 shll %cl, %ebx
0xf7, 0xd3, //0x00000763 notl %ebx
0x41, 0x21, 0xdb, //0x00000765 andl %ebx, %r11d
0x21, 0xda, //0x00000768 andl %ebx, %edx
0x21, 0xf3, //0x0000076a andl %esi, %ebx
0x89, 0xde, //0x0000076c movl %ebx, %esi
//0x0000076e LBB0_90
0x41, 0x8d, 0x5b, 0xff, //0x0000076e leal $-1(%r11), %ebx
0x44, 0x21, 0xdb, //0x00000772 andl %r11d, %ebx
0x0f, 0x85, 0x12, 0x1f, 0x00, 0x00, //0x00000775 jne LBB0_429
0x8d, 0x5a, 0xff, //0x0000077b leal $-1(%rdx), %ebx
0x21, 0xd3, //0x0000077e andl %edx, %ebx
0x0f, 0x85, 0x07, 0x1f, 0x00, 0x00, //0x00000780 jne LBB0_429
0x8d, 0x5e, 0xff, //0x00000786 leal $-1(%rsi), %ebx
0x21, 0xf3, //0x00000789 andl %esi, %ebx
0x0f, 0x85, 0xfc, 0x1e, 0x00, 0x00, //0x0000078b jne LBB0_429
0x45, 0x85, 0xdb, //0x00000791 testl %r11d, %r11d
0x0f, 0x84, 0x14, 0x00, 0x00, 0x00, //0x00000794 je LBB0_96
0x41, 0x0f, 0xbc, 0xdb, //0x0000079a bsfl %r11d, %ebx
0x49, 0x83, 0xf8, 0xff, //0x0000079e cmpq $-1, %r8
0x0f, 0x85, 0x75, 0x22, 0x00, 0x00, //0x000007a2 jne LBB0_436
0x4c, 0x01, 0xeb, //0x000007a8 addq %r13, %rbx
0x49, 0x89, 0xd8, //0x000007ab movq %rbx, %r8
//0x000007ae LBB0_96
0x85, 0xd2, //0x000007ae testl %edx, %edx
0x0f, 0x84, 0x13, 0x00, 0x00, 0x00, //0x000007b0 je LBB0_99
0x0f, 0xbc, 0xd2, //0x000007b6 bsfl %edx, %edx
0x49, 0x83, 0xff, 0xff, //0x000007b9 cmpq $-1, %r15
0x0f, 0x85, 0xd1, 0x20, 0x00, 0x00, //0x000007bd jne LBB0_435
0x4c, 0x01, 0xea, //0x000007c3 addq %r13, %rdx
0x49, 0x89, 0xd7, //0x000007c6 movq %rdx, %r15
//0x000007c9 LBB0_99
0x85, 0xf6, //0x000007c9 testl %esi, %esi
0x0f, 0x84, 0x13, 0x00, 0x00, 0x00, //0x000007cb je LBB0_102
0x0f, 0xbc, 0xd6, //0x000007d1 bsfl %esi, %edx
0x49, 0x83, 0xf9, 0xff, //0x000007d4 cmpq $-1, %r9
0x0f, 0x85, 0xb6, 0x20, 0x00, 0x00, //0x000007d8 jne LBB0_435
0x4c, 0x01, 0xea, //0x000007de addq %r13, %rdx
0x49, 0x89, 0xd1, //0x000007e1 movq %rdx, %r9
//0x000007e4 LBB0_102
0x83, 0xf9, 0x10, //0x000007e4 cmpl $16, %ecx
0x0f, 0x85, 0xbb, 0x07, 0x00, 0x00, //0x000007e7 jne LBB0_183
0x49, 0x83, 0xc2, 0xf0, //0x000007ed addq $-16, %r10
0x49, 0x83, 0xc5, 0x10, //0x000007f1 addq $16, %r13
0x49, 0x83, 0xfa, 0x0f, //0x000007f5 cmpq $15, %r10
0x0f, 0x87, 0xe1, 0xfe, 0xff, 0xff, //0x000007f9 ja LBB0_88
0x4b, 0x8d, 0x0c, 0x2e, //0x000007ff leaq (%r14,%r13), %rcx
0x49, 0x89, 0xcb, //0x00000803 movq %rcx, %r11
0x4c, 0x39, 0xef, //0x00000806 cmpq %r13, %rdi
0x0f, 0x84, 0xa2, 0x07, 0x00, 0x00, //0x00000809 je LBB0_184
//0x0000080f LBB0_105
0x4e, 0x8d, 0x1c, 0x11, //0x0000080f leaq (%rcx,%r10), %r11
0x48, 0x89, 0xca, //0x00000813 movq %rcx, %rdx
0x48, 0x2b, 0x55, 0xc0, //0x00000816 subq $-64(%rbp), %rdx
0x4c, 0x29, 0xe2, //0x0000081a subq %r12, %rdx
0x48, 0x83, 0xc2, 0x01, //0x0000081d addq $1, %rdx
0x31, 0xff, //0x00000821 xorl %edi, %edi
0x4c, 0x8d, 0x2d, 0x2a, 0x37, 0x00, 0x00, //0x00000823 leaq $14122(%rip), %r13 /* LJTI0_3+0(%rip) */
0xe9, 0x2e, 0x00, 0x00, 0x00, //0x0000082a jmp LBB0_110
//0x0000082f LBB0_106
0x83, 0xfe, 0x65, //0x0000082f cmpl $101, %esi
0x0f, 0x85, 0xbc, 0x09, 0x00, 0x00, //0x00000832 jne LBB0_212
//0x00000838 LBB0_107
0x49, 0x83, 0xff, 0xff, //0x00000838 cmpq $-1, %r15
0x0f, 0x85, 0x76, 0x1e, 0x00, 0x00, //0x0000083c jne LBB0_433
0x4c, 0x8d, 0x3c, 0x3a, //0x00000842 leaq (%rdx,%rdi), %r15
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000846 .p2align 4, 0x90
//0x00000850 LBB0_109
0x48, 0x83, 0xc7, 0x01, //0x00000850 addq $1, %rdi
0x49, 0x39, 0xfa, //0x00000854 cmpq %rdi, %r10
0x0f, 0x84, 0x54, 0x07, 0x00, 0x00, //0x00000857 je LBB0_184
//0x0000085d LBB0_110
0x0f, 0xbe, 0x34, 0x39, //0x0000085d movsbl (%rcx,%rdi), %esi
0x8d, 0x5e, 0xd0, //0x00000861 leal $-48(%rsi), %ebx
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | true |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/validate_utf8_fast_subr.go | vendor/github.com/bytedance/sonic/internal/native/sse/validate_utf8_fast_subr.go | // +build !noasm !appengine
// Code generated by asm2asm, DO NOT EDIT.
package sse
import (
`github.com/bytedance/sonic/loader`
)
const (
_entry__validate_utf8_fast = 0
)
const (
_stack__validate_utf8_fast = 24
)
const (
_size__validate_utf8_fast = 536
)
var (
_pcsp__validate_utf8_fast = [][2]uint32{
{0x1, 0},
{0x5, 8},
{0x6, 16},
{0xfb, 24},
{0xfc, 16},
{0xfd, 8},
{0xfe, 0},
{0x213, 24},
{0x214, 16},
{0x215, 8},
{0x218, 0},
}
)
var _cfunc_validate_utf8_fast = []loader.CFunc{
{"_validate_utf8_fast_entry", 0, _entry__validate_utf8_fast, 0, nil},
{"_validate_utf8_fast", _entry__validate_utf8_fast, _size__validate_utf8_fast, _stack__validate_utf8_fast, _pcsp__validate_utf8_fast},
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/native_export.go | vendor/github.com/bytedance/sonic/internal/native/sse/native_export.go |
// 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
import (
`github.com/bytedance/sonic/loader`
)
func Use() {
loader.WrapGoC(_text_f64toa, _cfunc_f64toa, []loader.GoC{{"_f64toa", &S_f64toa, &F_f64toa}}, "sse", "sse/f64toa.c")
loader.WrapGoC(_text_f32toa, _cfunc_f32toa, []loader.GoC{{"_f32toa", &S_f32toa, &F_f32toa}}, "sse", "sse/f32toa.c")
loader.WrapGoC(_text_get_by_path, _cfunc_get_by_path, []loader.GoC{{"_get_by_path", &S_get_by_path, &F_get_by_path}}, "sse", "sse/get_by_path.c")
loader.WrapGoC(_text_html_escape, _cfunc_html_escape, []loader.GoC{{"_html_escape", &S_html_escape, &F_html_escape}}, "sse", "sse/html_escape.c")
loader.WrapGoC(_text_i64toa, _cfunc_i64toa, []loader.GoC{{"_i64toa", &S_i64toa, &F_i64toa}}, "sse", "sse/i64toa.c")
loader.WrapGoC(_text_lspace, _cfunc_lspace, []loader.GoC{{"_lspace", &S_lspace, &F_lspace}}, "sse", "sse/lspace.c")
loader.WrapGoC(_text_quote, _cfunc_quote, []loader.GoC{{"_quote", &S_quote, &F_quote}}, "sse", "sse/quote.c")
loader.WrapGoC(_text_skip_array, _cfunc_skip_array, []loader.GoC{{"_skip_array", &S_skip_array, &F_skip_array}}, "sse", "sse/skip_array.c")
loader.WrapGoC(_text_skip_number, _cfunc_skip_number, []loader.GoC{{"_skip_number", &S_skip_number, &F_skip_number}}, "sse", "sse/skip_number.c")
loader.WrapGoC(_text_skip_one, _cfunc_skip_one, []loader.GoC{{"_skip_one", &S_skip_one, &F_skip_one}}, "sse", "sse/skip_one.c")
loader.WrapGoC(_text_skip_object, _cfunc_skip_object, []loader.GoC{{"_skip_object", &S_skip_object, &F_skip_object}}, "sse", "sse/skip_object.c")
loader.WrapGoC(_text_skip_one_fast, _cfunc_skip_one_fast, []loader.GoC{{"_skip_one_fast", &S_skip_one_fast, &F_skip_one_fast}}, "sse", "sse/skip_one_fast.c")
loader.WrapGoC(_text_u64toa, _cfunc_u64toa, []loader.GoC{{"_u64toa", &S_u64toa, &F_u64toa}}, "sse", "sse/u64toa.c")
loader.WrapGoC(_text_unquote, _cfunc_unquote, []loader.GoC{{"_unquote", &S_unquote, &F_unquote}}, "sse", "sse/unquote.c")
loader.WrapGoC(_text_validate_one, _cfunc_validate_one, []loader.GoC{{"_validate_one", &S_validate_one, &F_validate_one}}, "sse", "sse/validate_one.c")
loader.WrapGoC(_text_validate_utf8, _cfunc_validate_utf8, []loader.GoC{{"_validate_utf8", &S_validate_utf8, &F_validate_utf8}}, "sse", "sse/validate_utf8.c")
loader.WrapGoC(_text_validate_utf8_fast, _cfunc_validate_utf8_fast, []loader.GoC{{"_validate_utf8_fast", &S_validate_utf8_fast, &F_validate_utf8_fast}}, "sse", "sse/validate_utf8_fast.c")
loader.WrapGoC(_text_vnumber, _cfunc_vnumber, []loader.GoC{{"_vnumber", &S_vnumber, &F_vnumber}}, "sse", "sse/vnumber.c")
loader.WrapGoC(_text_vsigned, _cfunc_vsigned, []loader.GoC{{"_vsigned", &S_vsigned, &F_vsigned}}, "sse", "sse/vsigned.c")
loader.WrapGoC(_text_vunsigned, _cfunc_vunsigned, []loader.GoC{{"_vunsigned", &S_vunsigned, &F_vunsigned}}, "sse", "sse/vunsigned.c")
loader.WrapGoC(_text_vstring, _cfunc_vstring, []loader.GoC{{"_vstring", &S_vstring, &F_vstring}}, "sse", "sse/vstring.c")
loader.WrapGoC(_text_value, _cfunc_value, []loader.GoC{{"_value", &S_value, &F_value}}, "sse", "sse/value.c")
loader.WrapGoC(_text_parse_with_padding, _cfunc_parse_with_padding, []loader.GoC{{"_parse_with_padding", &S_parse_with_padding, &F_parse_with_padding}}, "sse", "sse/parser.c")
loader.WrapGoC(_text_lookup_small_key, _cfunc_lookup_small_key, []loader.GoC{{"_lookup_small_key", &S_lookup_small_key, &F_lookup_small_key}}, "sse", "sse/lookup.c")
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/u64toa_text_amd64.go | vendor/github.com/bytedance/sonic/internal/native/sse/u64toa_text_amd64.go | // +build amd64
// Code generated by asm2asm, DO NOT EDIT.
package sse
var _text_u64toa = []byte{
// .p2align 4, 0x00
// LCPI0_0
0x59, 0x17, 0xb7, 0xd1, 0x00, 0x00, 0x00, 0x00, // .quad 3518437209
0x59, 0x17, 0xb7, 0xd1, 0x00, 0x00, 0x00, 0x00, //0x00000008 .quad 3518437209
//0x00000010 LCPI0_1
0xc5, 0x20, //0x00000010 .word 8389
0x7b, 0x14, //0x00000012 .word 5243
0x34, 0x33, //0x00000014 .word 13108
0x00, 0x80, //0x00000016 .word 32768
0xc5, 0x20, //0x00000018 .word 8389
0x7b, 0x14, //0x0000001a .word 5243
0x34, 0x33, //0x0000001c .word 13108
0x00, 0x80, //0x0000001e .word 32768
//0x00000020 LCPI0_2
0x80, 0x00, //0x00000020 .word 128
0x00, 0x08, //0x00000022 .word 2048
0x00, 0x20, //0x00000024 .word 8192
0x00, 0x80, //0x00000026 .word 32768
0x80, 0x00, //0x00000028 .word 128
0x00, 0x08, //0x0000002a .word 2048
0x00, 0x20, //0x0000002c .word 8192
0x00, 0x80, //0x0000002e .word 32768
//0x00000030 LCPI0_3
0x0a, 0x00, //0x00000030 .word 10
0x0a, 0x00, //0x00000032 .word 10
0x0a, 0x00, //0x00000034 .word 10
0x0a, 0x00, //0x00000036 .word 10
0x0a, 0x00, //0x00000038 .word 10
0x0a, 0x00, //0x0000003a .word 10
0x0a, 0x00, //0x0000003c .word 10
0x0a, 0x00, //0x0000003e .word 10
//0x00000040 LCPI0_4
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, //0x00000040 QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000'
//0x00000050 .p2align 4, 0x90
//0x00000050 _u64toa
0x55, //0x00000050 pushq %rbp
0x48, 0x89, 0xe5, //0x00000051 movq %rsp, %rbp
0x48, 0x81, 0xfe, 0x0f, 0x27, 0x00, 0x00, //0x00000054 cmpq $9999, %rsi
0x0f, 0x87, 0xa5, 0x00, 0x00, 0x00, //0x0000005b ja LBB0_8
0x0f, 0xb7, 0xc6, //0x00000061 movzwl %si, %eax
0xc1, 0xe8, 0x02, //0x00000064 shrl $2, %eax
0x69, 0xc0, 0x7b, 0x14, 0x00, 0x00, //0x00000067 imull $5243, %eax, %eax
0xc1, 0xe8, 0x11, //0x0000006d shrl $17, %eax
0x48, 0x8d, 0x14, 0x00, //0x00000070 leaq (%rax,%rax), %rdx
0x6b, 0xc0, 0x64, //0x00000074 imull $100, %eax, %eax
0x89, 0xf1, //0x00000077 movl %esi, %ecx
0x29, 0xc1, //0x00000079 subl %eax, %ecx
0x0f, 0xb7, 0xc1, //0x0000007b movzwl %cx, %eax
0x48, 0x01, 0xc0, //0x0000007e addq %rax, %rax
0x81, 0xfe, 0xe8, 0x03, 0x00, 0x00, //0x00000081 cmpl $1000, %esi
0x0f, 0x82, 0x16, 0x00, 0x00, 0x00, //0x00000087 jb LBB0_3
0x48, 0x8d, 0x0d, 0x8c, 0x04, 0x00, 0x00, //0x0000008d leaq $1164(%rip), %rcx /* _Digits+0(%rip) */
0x8a, 0x0c, 0x0a, //0x00000094 movb (%rdx,%rcx), %cl
0x88, 0x0f, //0x00000097 movb %cl, (%rdi)
0xb9, 0x01, 0x00, 0x00, 0x00, //0x00000099 movl $1, %ecx
0xe9, 0x0b, 0x00, 0x00, 0x00, //0x0000009e jmp LBB0_4
//0x000000a3 LBB0_3
0x31, 0xc9, //0x000000a3 xorl %ecx, %ecx
0x83, 0xfe, 0x64, //0x000000a5 cmpl $100, %esi
0x0f, 0x82, 0x48, 0x00, 0x00, 0x00, //0x000000a8 jb LBB0_5
//0x000000ae LBB0_4
0x0f, 0xb7, 0xd2, //0x000000ae movzwl %dx, %edx
0x48, 0x83, 0xca, 0x01, //0x000000b1 orq $1, %rdx
0x48, 0x8d, 0x35, 0x64, 0x04, 0x00, 0x00, //0x000000b5 leaq $1124(%rip), %rsi /* _Digits+0(%rip) */
0x8a, 0x14, 0x32, //0x000000bc movb (%rdx,%rsi), %dl
0x89, 0xce, //0x000000bf movl %ecx, %esi
0x83, 0xc1, 0x01, //0x000000c1 addl $1, %ecx
0x88, 0x14, 0x37, //0x000000c4 movb %dl, (%rdi,%rsi)
//0x000000c7 LBB0_6
0x48, 0x8d, 0x15, 0x52, 0x04, 0x00, 0x00, //0x000000c7 leaq $1106(%rip), %rdx /* _Digits+0(%rip) */
0x8a, 0x14, 0x10, //0x000000ce movb (%rax,%rdx), %dl
0x89, 0xce, //0x000000d1 movl %ecx, %esi
0x83, 0xc1, 0x01, //0x000000d3 addl $1, %ecx
0x88, 0x14, 0x37, //0x000000d6 movb %dl, (%rdi,%rsi)
//0x000000d9 LBB0_7
0x0f, 0xb7, 0xc0, //0x000000d9 movzwl %ax, %eax
0x48, 0x83, 0xc8, 0x01, //0x000000dc orq $1, %rax
0x48, 0x8d, 0x15, 0x39, 0x04, 0x00, 0x00, //0x000000e0 leaq $1081(%rip), %rdx /* _Digits+0(%rip) */
0x8a, 0x04, 0x10, //0x000000e7 movb (%rax,%rdx), %al
0x89, 0xca, //0x000000ea movl %ecx, %edx
0x83, 0xc1, 0x01, //0x000000ec addl $1, %ecx
0x88, 0x04, 0x17, //0x000000ef movb %al, (%rdi,%rdx)
0x89, 0xc8, //0x000000f2 movl %ecx, %eax
0x5d, //0x000000f4 popq %rbp
0xc3, //0x000000f5 retq
//0x000000f6 LBB0_5
0x31, 0xc9, //0x000000f6 xorl %ecx, %ecx
0x83, 0xfe, 0x0a, //0x000000f8 cmpl $10, %esi
0x0f, 0x83, 0xc6, 0xff, 0xff, 0xff, //0x000000fb jae LBB0_6
0xe9, 0xd3, 0xff, 0xff, 0xff, //0x00000101 jmp LBB0_7
//0x00000106 LBB0_8
0x48, 0x81, 0xfe, 0xff, 0xe0, 0xf5, 0x05, //0x00000106 cmpq $99999999, %rsi
0x0f, 0x87, 0x20, 0x01, 0x00, 0x00, //0x0000010d ja LBB0_16
0x89, 0xf0, //0x00000113 movl %esi, %eax
0xba, 0x59, 0x17, 0xb7, 0xd1, //0x00000115 movl $3518437209, %edx
0x48, 0x0f, 0xaf, 0xd0, //0x0000011a imulq %rax, %rdx
0x48, 0xc1, 0xea, 0x2d, //0x0000011e shrq $45, %rdx
0x44, 0x69, 0xc2, 0x10, 0x27, 0x00, 0x00, //0x00000122 imull $10000, %edx, %r8d
0x89, 0xf1, //0x00000129 movl %esi, %ecx
0x44, 0x29, 0xc1, //0x0000012b subl %r8d, %ecx
0x4c, 0x69, 0xd0, 0x83, 0xde, 0x1b, 0x43, //0x0000012e imulq $1125899907, %rax, %r10
0x49, 0xc1, 0xea, 0x31, //0x00000135 shrq $49, %r10
0x41, 0x83, 0xe2, 0xfe, //0x00000139 andl $-2, %r10d
0x0f, 0xb7, 0xc2, //0x0000013d movzwl %dx, %eax
0xc1, 0xe8, 0x02, //0x00000140 shrl $2, %eax
0x69, 0xc0, 0x7b, 0x14, 0x00, 0x00, //0x00000143 imull $5243, %eax, %eax
0xc1, 0xe8, 0x11, //0x00000149 shrl $17, %eax
0x6b, 0xc0, 0x64, //0x0000014c imull $100, %eax, %eax
0x29, 0xc2, //0x0000014f subl %eax, %edx
0x44, 0x0f, 0xb7, 0xca, //0x00000151 movzwl %dx, %r9d
0x4d, 0x01, 0xc9, //0x00000155 addq %r9, %r9
0x0f, 0xb7, 0xc1, //0x00000158 movzwl %cx, %eax
0xc1, 0xe8, 0x02, //0x0000015b shrl $2, %eax
0x69, 0xc0, 0x7b, 0x14, 0x00, 0x00, //0x0000015e imull $5243, %eax, %eax
0xc1, 0xe8, 0x11, //0x00000164 shrl $17, %eax
0x4c, 0x8d, 0x04, 0x00, //0x00000167 leaq (%rax,%rax), %r8
0x6b, 0xc0, 0x64, //0x0000016b imull $100, %eax, %eax
0x29, 0xc1, //0x0000016e subl %eax, %ecx
0x44, 0x0f, 0xb7, 0xd9, //0x00000170 movzwl %cx, %r11d
0x4d, 0x01, 0xdb, //0x00000174 addq %r11, %r11
0x81, 0xfe, 0x80, 0x96, 0x98, 0x00, //0x00000177 cmpl $10000000, %esi
0x0f, 0x82, 0x17, 0x00, 0x00, 0x00, //0x0000017d jb LBB0_11
0x48, 0x8d, 0x05, 0x96, 0x03, 0x00, 0x00, //0x00000183 leaq $918(%rip), %rax /* _Digits+0(%rip) */
0x41, 0x8a, 0x04, 0x02, //0x0000018a movb (%r10,%rax), %al
0x88, 0x07, //0x0000018e movb %al, (%rdi)
0xb9, 0x01, 0x00, 0x00, 0x00, //0x00000190 movl $1, %ecx
0xe9, 0x0e, 0x00, 0x00, 0x00, //0x00000195 jmp LBB0_12
//0x0000019a LBB0_11
0x31, 0xc9, //0x0000019a xorl %ecx, %ecx
0x81, 0xfe, 0x40, 0x42, 0x0f, 0x00, //0x0000019c cmpl $1000000, %esi
0x0f, 0x82, 0x78, 0x00, 0x00, 0x00, //0x000001a2 jb LBB0_13
//0x000001a8 LBB0_12
0x44, 0x89, 0xd0, //0x000001a8 movl %r10d, %eax
0x48, 0x83, 0xc8, 0x01, //0x000001ab orq $1, %rax
0x48, 0x8d, 0x35, 0x6a, 0x03, 0x00, 0x00, //0x000001af leaq $874(%rip), %rsi /* _Digits+0(%rip) */
0x8a, 0x04, 0x30, //0x000001b6 movb (%rax,%rsi), %al
0x89, 0xce, //0x000001b9 movl %ecx, %esi
0x83, 0xc1, 0x01, //0x000001bb addl $1, %ecx
0x88, 0x04, 0x37, //0x000001be movb %al, (%rdi,%rsi)
//0x000001c1 LBB0_14
0x48, 0x8d, 0x05, 0x58, 0x03, 0x00, 0x00, //0x000001c1 leaq $856(%rip), %rax /* _Digits+0(%rip) */
0x41, 0x8a, 0x04, 0x01, //0x000001c8 movb (%r9,%rax), %al
0x89, 0xce, //0x000001cc movl %ecx, %esi
0x83, 0xc1, 0x01, //0x000001ce addl $1, %ecx
0x88, 0x04, 0x37, //0x000001d1 movb %al, (%rdi,%rsi)
//0x000001d4 LBB0_15
0x41, 0x0f, 0xb7, 0xc1, //0x000001d4 movzwl %r9w, %eax
0x48, 0x83, 0xc8, 0x01, //0x000001d8 orq $1, %rax
0x48, 0x8d, 0x35, 0x3d, 0x03, 0x00, 0x00, //0x000001dc leaq $829(%rip), %rsi /* _Digits+0(%rip) */
0x8a, 0x04, 0x30, //0x000001e3 movb (%rax,%rsi), %al
0x89, 0xca, //0x000001e6 movl %ecx, %edx
0x88, 0x04, 0x17, //0x000001e8 movb %al, (%rdi,%rdx)
0x41, 0x8a, 0x04, 0x30, //0x000001eb movb (%r8,%rsi), %al
0x88, 0x44, 0x17, 0x01, //0x000001ef movb %al, $1(%rdi,%rdx)
0x41, 0x0f, 0xb7, 0xc0, //0x000001f3 movzwl %r8w, %eax
0x48, 0x83, 0xc8, 0x01, //0x000001f7 orq $1, %rax
0x8a, 0x04, 0x30, //0x000001fb movb (%rax,%rsi), %al
0x88, 0x44, 0x17, 0x02, //0x000001fe movb %al, $2(%rdi,%rdx)
0x41, 0x8a, 0x04, 0x33, //0x00000202 movb (%r11,%rsi), %al
0x88, 0x44, 0x17, 0x03, //0x00000206 movb %al, $3(%rdi,%rdx)
0x41, 0x0f, 0xb7, 0xc3, //0x0000020a movzwl %r11w, %eax
0x48, 0x83, 0xc8, 0x01, //0x0000020e orq $1, %rax
0x8a, 0x04, 0x30, //0x00000212 movb (%rax,%rsi), %al
0x83, 0xc1, 0x05, //0x00000215 addl $5, %ecx
0x88, 0x44, 0x17, 0x04, //0x00000218 movb %al, $4(%rdi,%rdx)
0x89, 0xc8, //0x0000021c movl %ecx, %eax
0x5d, //0x0000021e popq %rbp
0xc3, //0x0000021f retq
//0x00000220 LBB0_13
0x31, 0xc9, //0x00000220 xorl %ecx, %ecx
0x81, 0xfe, 0xa0, 0x86, 0x01, 0x00, //0x00000222 cmpl $100000, %esi
0x0f, 0x83, 0x93, 0xff, 0xff, 0xff, //0x00000228 jae LBB0_14
0xe9, 0xa1, 0xff, 0xff, 0xff, //0x0000022e jmp LBB0_15
//0x00000233 LBB0_16
0x48, 0xb8, 0xff, 0xff, 0xc0, 0x6f, 0xf2, 0x86, 0x23, 0x00, //0x00000233 movabsq $9999999999999999, %rax
0x48, 0x39, 0xc6, //0x0000023d cmpq %rax, %rsi
0x0f, 0x87, 0x12, 0x01, 0x00, 0x00, //0x00000240 ja LBB0_18
0x48, 0xb9, 0xfd, 0xce, 0x61, 0x84, 0x11, 0x77, 0xcc, 0xab, //0x00000246 movabsq $-6067343680855748867, %rcx
0x48, 0x89, 0xf0, //0x00000250 movq %rsi, %rax
0x48, 0xf7, 0xe1, //0x00000253 mulq %rcx
0x48, 0xc1, 0xea, 0x1a, //0x00000256 shrq $26, %rdx
0x69, 0xc2, 0x00, 0xe1, 0xf5, 0x05, //0x0000025a imull $100000000, %edx, %eax
0x29, 0xc6, //0x00000260 subl %eax, %esi
0x66, 0x0f, 0x6e, 0xc2, //0x00000262 movd %edx, %xmm0
0xf3, 0x0f, 0x6f, 0x0d, 0x92, 0xfd, 0xff, 0xff, //0x00000266 movdqu $-622(%rip), %xmm1 /* LCPI0_0+0(%rip) */
0x66, 0x0f, 0x6f, 0xd0, //0x0000026e movdqa %xmm0, %xmm2
0x66, 0x0f, 0xf4, 0xd1, //0x00000272 pmuludq %xmm1, %xmm2
0x66, 0x0f, 0x73, 0xd2, 0x2d, //0x00000276 psrlq $45, %xmm2
0xb8, 0x10, 0x27, 0x00, 0x00, //0x0000027b movl $10000, %eax
0x66, 0x48, 0x0f, 0x6e, 0xd8, //0x00000280 movq %rax, %xmm3
0x66, 0x0f, 0x6f, 0xe2, //0x00000285 movdqa %xmm2, %xmm4
0x66, 0x0f, 0xf4, 0xe3, //0x00000289 pmuludq %xmm3, %xmm4
0x66, 0x0f, 0xfa, 0xc4, //0x0000028d psubd %xmm4, %xmm0
0x66, 0x0f, 0x61, 0xd0, //0x00000291 punpcklwd %xmm0, %xmm2
0x66, 0x0f, 0x73, 0xf2, 0x02, //0x00000295 psllq $2, %xmm2
0xf2, 0x0f, 0x70, 0xc2, 0x50, //0x0000029a pshuflw $80, %xmm2, %xmm0
0x66, 0x0f, 0x70, 0xc0, 0x50, //0x0000029f pshufd $80, %xmm0, %xmm0
0xf3, 0x0f, 0x6f, 0x15, 0x64, 0xfd, 0xff, 0xff, //0x000002a4 movdqu $-668(%rip), %xmm2 /* LCPI0_1+0(%rip) */
0x66, 0x0f, 0xe4, 0xc2, //0x000002ac pmulhuw %xmm2, %xmm0
0xf3, 0x0f, 0x6f, 0x25, 0x68, 0xfd, 0xff, 0xff, //0x000002b0 movdqu $-664(%rip), %xmm4 /* LCPI0_2+0(%rip) */
0x66, 0x0f, 0xe4, 0xc4, //0x000002b8 pmulhuw %xmm4, %xmm0
0xf3, 0x0f, 0x6f, 0x2d, 0x6c, 0xfd, 0xff, 0xff, //0x000002bc movdqu $-660(%rip), %xmm5 /* LCPI0_3+0(%rip) */
0x66, 0x0f, 0x6f, 0xf0, //0x000002c4 movdqa %xmm0, %xmm6
0x66, 0x0f, 0xd5, 0xf5, //0x000002c8 pmullw %xmm5, %xmm6
0x66, 0x0f, 0x73, 0xf6, 0x10, //0x000002cc psllq $16, %xmm6
0x66, 0x0f, 0xf9, 0xc6, //0x000002d1 psubw %xmm6, %xmm0
0x66, 0x0f, 0x6e, 0xf6, //0x000002d5 movd %esi, %xmm6
0x66, 0x0f, 0xf4, 0xce, //0x000002d9 pmuludq %xmm6, %xmm1
0x66, 0x0f, 0x73, 0xd1, 0x2d, //0x000002dd psrlq $45, %xmm1
0x66, 0x0f, 0xf4, 0xd9, //0x000002e2 pmuludq %xmm1, %xmm3
0x66, 0x0f, 0xfa, 0xf3, //0x000002e6 psubd %xmm3, %xmm6
0x66, 0x0f, 0x61, 0xce, //0x000002ea punpcklwd %xmm6, %xmm1
0x66, 0x0f, 0x73, 0xf1, 0x02, //0x000002ee psllq $2, %xmm1
0xf2, 0x0f, 0x70, 0xc9, 0x50, //0x000002f3 pshuflw $80, %xmm1, %xmm1
0x66, 0x0f, 0x70, 0xc9, 0x50, //0x000002f8 pshufd $80, %xmm1, %xmm1
0x66, 0x0f, 0xe4, 0xca, //0x000002fd pmulhuw %xmm2, %xmm1
0x66, 0x0f, 0xe4, 0xcc, //0x00000301 pmulhuw %xmm4, %xmm1
0x66, 0x0f, 0xd5, 0xe9, //0x00000305 pmullw %xmm1, %xmm5
0x66, 0x0f, 0x73, 0xf5, 0x10, //0x00000309 psllq $16, %xmm5
0x66, 0x0f, 0xf9, 0xcd, //0x0000030e psubw %xmm5, %xmm1
0x66, 0x0f, 0x67, 0xc1, //0x00000312 packuswb %xmm1, %xmm0
0xf3, 0x0f, 0x6f, 0x0d, 0x22, 0xfd, 0xff, 0xff, //0x00000316 movdqu $-734(%rip), %xmm1 /* LCPI0_4+0(%rip) */
0x66, 0x0f, 0xfc, 0xc8, //0x0000031e paddb %xmm0, %xmm1
0x66, 0x0f, 0xef, 0xd2, //0x00000322 pxor %xmm2, %xmm2
0x66, 0x0f, 0x74, 0xd0, //0x00000326 pcmpeqb %xmm0, %xmm2
0x66, 0x0f, 0xd7, 0xc2, //0x0000032a pmovmskb %xmm2, %eax
0xf7, 0xd0, //0x0000032e notl %eax
0x0d, 0x00, 0x80, 0x00, 0x00, //0x00000330 orl $32768, %eax
0x0f, 0xbc, 0xc0, //0x00000335 bsfl %eax, %eax
0xb9, 0x10, 0x00, 0x00, 0x00, //0x00000338 movl $16, %ecx
0x29, 0xc1, //0x0000033d subl %eax, %ecx
0x48, 0xc1, 0xe0, 0x04, //0x0000033f shlq $4, %rax
0x48, 0x8d, 0x15, 0xa6, 0x02, 0x00, 0x00, //0x00000343 leaq $678(%rip), %rdx /* _VecShiftShuffles+0(%rip) */
0x66, 0x0f, 0x38, 0x00, 0x0c, 0x10, //0x0000034a pshufb (%rax,%rdx), %xmm1
0xf3, 0x0f, 0x7f, 0x0f, //0x00000350 movdqu %xmm1, (%rdi)
0x89, 0xc8, //0x00000354 movl %ecx, %eax
0x5d, //0x00000356 popq %rbp
0xc3, //0x00000357 retq
//0x00000358 LBB0_18
0x48, 0xb9, 0x57, 0x78, 0x13, 0xb1, 0x2f, 0x65, 0xa5, 0x39, //0x00000358 movabsq $4153837486827862103, %rcx
0x48, 0x89, 0xf0, //0x00000362 movq %rsi, %rax
0x48, 0xf7, 0xe1, //0x00000365 mulq %rcx
0x48, 0xc1, 0xea, 0x33, //0x00000368 shrq $51, %rdx
0x48, 0xb8, 0x00, 0x00, 0xc1, 0x6f, 0xf2, 0x86, 0x23, 0x00, //0x0000036c movabsq $10000000000000000, %rax
0x48, 0x0f, 0xaf, 0xc2, //0x00000376 imulq %rdx, %rax
0x48, 0x29, 0xc6, //0x0000037a subq %rax, %rsi
0x83, 0xfa, 0x09, //0x0000037d cmpl $9, %edx
0x0f, 0x87, 0x0f, 0x00, 0x00, 0x00, //0x00000380 ja LBB0_20
0x80, 0xc2, 0x30, //0x00000386 addb $48, %dl
0x88, 0x17, //0x00000389 movb %dl, (%rdi)
0xb9, 0x01, 0x00, 0x00, 0x00, //0x0000038b movl $1, %ecx
0xe9, 0xa5, 0x00, 0x00, 0x00, //0x00000390 jmp LBB0_25
//0x00000395 LBB0_20
0x83, 0xfa, 0x63, //0x00000395 cmpl $99, %edx
0x0f, 0x87, 0x1a, 0x00, 0x00, 0x00, //0x00000398 ja LBB0_22
0x89, 0xd0, //0x0000039e movl %edx, %eax
0x48, 0x8d, 0x0d, 0x79, 0x01, 0x00, 0x00, //0x000003a0 leaq $377(%rip), %rcx /* _Digits+0(%rip) */
0x0f, 0xb7, 0x04, 0x41, //0x000003a7 movzwl (%rcx,%rax,2), %eax
0x66, 0x89, 0x07, //0x000003ab movw %ax, (%rdi)
0xb9, 0x02, 0x00, 0x00, 0x00, //0x000003ae movl $2, %ecx
0xe9, 0x82, 0x00, 0x00, 0x00, //0x000003b3 jmp LBB0_25
//0x000003b8 LBB0_22
0x89, 0xd0, //0x000003b8 movl %edx, %eax
0xc1, 0xe8, 0x02, //0x000003ba shrl $2, %eax
0x69, 0xc0, 0x7b, 0x14, 0x00, 0x00, //0x000003bd imull $5243, %eax, %eax
0xc1, 0xe8, 0x11, //0x000003c3 shrl $17, %eax
0x81, 0xfa, 0xe7, 0x03, 0x00, 0x00, //0x000003c6 cmpl $999, %edx
0x0f, 0x87, 0x37, 0x00, 0x00, 0x00, //0x000003cc ja LBB0_24
0x83, 0xc0, 0x30, //0x000003d2 addl $48, %eax
0x88, 0x07, //0x000003d5 movb %al, (%rdi)
0x0f, 0xb7, 0xc2, //0x000003d7 movzwl %dx, %eax
0x89, 0xc1, //0x000003da movl %eax, %ecx
0xc1, 0xe9, 0x02, //0x000003dc shrl $2, %ecx
0x69, 0xc9, 0x7b, 0x14, 0x00, 0x00, //0x000003df imull $5243, %ecx, %ecx
0xc1, 0xe9, 0x11, //0x000003e5 shrl $17, %ecx
0x6b, 0xc9, 0x64, //0x000003e8 imull $100, %ecx, %ecx
0x29, 0xc8, //0x000003eb subl %ecx, %eax
0x0f, 0xb7, 0xc0, //0x000003ed movzwl %ax, %eax
0x48, 0x8d, 0x0d, 0x29, 0x01, 0x00, 0x00, //0x000003f0 leaq $297(%rip), %rcx /* _Digits+0(%rip) */
0x0f, 0xb7, 0x04, 0x41, //0x000003f7 movzwl (%rcx,%rax,2), %eax
0x66, 0x89, 0x47, 0x01, //0x000003fb movw %ax, $1(%rdi)
0xb9, 0x03, 0x00, 0x00, 0x00, //0x000003ff movl $3, %ecx
0xe9, 0x31, 0x00, 0x00, 0x00, //0x00000404 jmp LBB0_25
//0x00000409 LBB0_24
0x6b, 0xc8, 0x64, //0x00000409 imull $100, %eax, %ecx
0x29, 0xca, //0x0000040c subl %ecx, %edx
0x0f, 0xb7, 0xc0, //0x0000040e movzwl %ax, %eax
0x48, 0x8d, 0x0d, 0x08, 0x01, 0x00, 0x00, //0x00000411 leaq $264(%rip), %rcx /* _Digits+0(%rip) */
0x0f, 0xb7, 0x04, 0x41, //0x00000418 movzwl (%rcx,%rax,2), %eax
0x66, 0x89, 0x07, //0x0000041c movw %ax, (%rdi)
0x0f, 0xb7, 0xc2, //0x0000041f movzwl %dx, %eax
0x8a, 0x14, 0x41, //0x00000422 movb (%rcx,%rax,2), %dl
0x48, 0x01, 0xc0, //0x00000425 addq %rax, %rax
0x88, 0x57, 0x02, //0x00000428 movb %dl, $2(%rdi)
0x0f, 0xb7, 0xc0, //0x0000042b movzwl %ax, %eax
0x8a, 0x44, 0x08, 0x01, //0x0000042e movb $1(%rax,%rcx), %al
0x88, 0x47, 0x03, //0x00000432 movb %al, $3(%rdi)
0xb9, 0x04, 0x00, 0x00, 0x00, //0x00000435 movl $4, %ecx
//0x0000043a LBB0_25
0x48, 0xba, 0xfd, 0xce, 0x61, 0x84, 0x11, 0x77, 0xcc, 0xab, //0x0000043a movabsq $-6067343680855748867, %rdx
0x48, 0x89, 0xf0, //0x00000444 movq %rsi, %rax
0x48, 0xf7, 0xe2, //0x00000447 mulq %rdx
0x48, 0xc1, 0xea, 0x1a, //0x0000044a shrq $26, %rdx
0x66, 0x0f, 0x6e, 0xc2, //0x0000044e movd %edx, %xmm0
0xf3, 0x0f, 0x6f, 0x0d, 0xa6, 0xfb, 0xff, 0xff, //0x00000452 movdqu $-1114(%rip), %xmm1 /* LCPI0_0+0(%rip) */
0x66, 0x0f, 0x6f, 0xd8, //0x0000045a movdqa %xmm0, %xmm3
0x66, 0x0f, 0xf4, 0xd9, //0x0000045e pmuludq %xmm1, %xmm3
0x66, 0x0f, 0x73, 0xd3, 0x2d, //0x00000462 psrlq $45, %xmm3
0xb8, 0x10, 0x27, 0x00, 0x00, //0x00000467 movl $10000, %eax
0x66, 0x48, 0x0f, 0x6e, 0xd0, //0x0000046c movq %rax, %xmm2
0x66, 0x0f, 0x6f, 0xe3, //0x00000471 movdqa %xmm3, %xmm4
0x66, 0x0f, 0xf4, 0xe2, //0x00000475 pmuludq %xmm2, %xmm4
0x66, 0x0f, 0xfa, 0xc4, //0x00000479 psubd %xmm4, %xmm0
0x66, 0x0f, 0x61, 0xd8, //0x0000047d punpcklwd %xmm0, %xmm3
0x66, 0x0f, 0x73, 0xf3, 0x02, //0x00000481 psllq $2, %xmm3
0xf2, 0x0f, 0x70, 0xc3, 0x50, //0x00000486 pshuflw $80, %xmm3, %xmm0
0x66, 0x0f, 0x70, 0xc0, 0x50, //0x0000048b pshufd $80, %xmm0, %xmm0
0xf3, 0x0f, 0x6f, 0x25, 0x78, 0xfb, 0xff, 0xff, //0x00000490 movdqu $-1160(%rip), %xmm4 /* LCPI0_1+0(%rip) */
0x66, 0x0f, 0xe4, 0xc4, //0x00000498 pmulhuw %xmm4, %xmm0
0xf3, 0x0f, 0x6f, 0x2d, 0x7c, 0xfb, 0xff, 0xff, //0x0000049c movdqu $-1156(%rip), %xmm5 /* LCPI0_2+0(%rip) */
0x66, 0x0f, 0xe4, 0xc5, //0x000004a4 pmulhuw %xmm5, %xmm0
0xf3, 0x0f, 0x6f, 0x1d, 0x80, 0xfb, 0xff, 0xff, //0x000004a8 movdqu $-1152(%rip), %xmm3 /* LCPI0_3+0(%rip) */
0x66, 0x0f, 0x6f, 0xf0, //0x000004b0 movdqa %xmm0, %xmm6
0x66, 0x0f, 0xd5, 0xf3, //0x000004b4 pmullw %xmm3, %xmm6
0x66, 0x0f, 0x73, 0xf6, 0x10, //0x000004b8 psllq $16, %xmm6
0x66, 0x0f, 0xf9, 0xc6, //0x000004bd psubw %xmm6, %xmm0
0x69, 0xc2, 0x00, 0xe1, 0xf5, 0x05, //0x000004c1 imull $100000000, %edx, %eax
0x29, 0xc6, //0x000004c7 subl %eax, %esi
0x66, 0x0f, 0x6e, 0xf6, //0x000004c9 movd %esi, %xmm6
0x66, 0x0f, 0xf4, 0xce, //0x000004cd pmuludq %xmm6, %xmm1
0x66, 0x0f, 0x73, 0xd1, 0x2d, //0x000004d1 psrlq $45, %xmm1
0x66, 0x0f, 0xf4, 0xd1, //0x000004d6 pmuludq %xmm1, %xmm2
0x66, 0x0f, 0xfa, 0xf2, //0x000004da psubd %xmm2, %xmm6
0x66, 0x0f, 0x61, 0xce, //0x000004de punpcklwd %xmm6, %xmm1
0x66, 0x0f, 0x73, 0xf1, 0x02, //0x000004e2 psllq $2, %xmm1
0xf2, 0x0f, 0x70, 0xc9, 0x50, //0x000004e7 pshuflw $80, %xmm1, %xmm1
0x66, 0x0f, 0x70, 0xc9, 0x50, //0x000004ec pshufd $80, %xmm1, %xmm1
0x66, 0x0f, 0xe4, 0xcc, //0x000004f1 pmulhuw %xmm4, %xmm1
0x66, 0x0f, 0xe4, 0xcd, //0x000004f5 pmulhuw %xmm5, %xmm1
0x66, 0x0f, 0xd5, 0xd9, //0x000004f9 pmullw %xmm1, %xmm3
0x66, 0x0f, 0x73, 0xf3, 0x10, //0x000004fd psllq $16, %xmm3
0x66, 0x0f, 0xf9, 0xcb, //0x00000502 psubw %xmm3, %xmm1
0x66, 0x0f, 0x67, 0xc1, //0x00000506 packuswb %xmm1, %xmm0
0x66, 0x0f, 0xfc, 0x05, 0x2e, 0xfb, 0xff, 0xff, //0x0000050a paddb $-1234(%rip), %xmm0 /* LCPI0_4+0(%rip) */
0x89, 0xc8, //0x00000512 movl %ecx, %eax
0xf3, 0x0f, 0x7f, 0x04, 0x07, //0x00000514 movdqu %xmm0, (%rdi,%rax)
0x83, 0xc9, 0x10, //0x00000519 orl $16, %ecx
0x89, 0xc8, //0x0000051c movl %ecx, %eax
0x5d, //0x0000051e popq %rbp
0xc3, //0x0000051f retq
//0x00000520 .p2align 4, 0x00
//0x00000520 _Digits
0x30, 0x30, 0x30, 0x31, 0x30, 0x32, 0x30, 0x33, 0x30, 0x34, 0x30, 0x35, 0x30, 0x36, 0x30, 0x37, //0x00000520 QUAD $0x3330323031303030; QUAD $0x3730363035303430 // .ascii 16, '0001020304050607'
0x30, 0x38, 0x30, 0x39, 0x31, 0x30, 0x31, 0x31, 0x31, 0x32, 0x31, 0x33, 0x31, 0x34, 0x31, 0x35, //0x00000530 QUAD $0x3131303139303830; QUAD $0x3531343133313231 // .ascii 16, '0809101112131415'
0x31, 0x36, 0x31, 0x37, 0x31, 0x38, 0x31, 0x39, 0x32, 0x30, 0x32, 0x31, 0x32, 0x32, 0x32, 0x33, //0x00000540 QUAD $0x3931383137313631; QUAD $0x3332323231323032 // .ascii 16, '1617181920212223'
0x32, 0x34, 0x32, 0x35, 0x32, 0x36, 0x32, 0x37, 0x32, 0x38, 0x32, 0x39, 0x33, 0x30, 0x33, 0x31, //0x00000550 QUAD $0x3732363235323432; QUAD $0x3133303339323832 // .ascii 16, '2425262728293031'
0x33, 0x32, 0x33, 0x33, 0x33, 0x34, 0x33, 0x35, 0x33, 0x36, 0x33, 0x37, 0x33, 0x38, 0x33, 0x39, //0x00000560 QUAD $0x3533343333333233; QUAD $0x3933383337333633 // .ascii 16, '3233343536373839'
0x34, 0x30, 0x34, 0x31, 0x34, 0x32, 0x34, 0x33, 0x34, 0x34, 0x34, 0x35, 0x34, 0x36, 0x34, 0x37, //0x00000570 QUAD $0x3334323431343034; QUAD $0x3734363435343434 // .ascii 16, '4041424344454647'
0x34, 0x38, 0x34, 0x39, 0x35, 0x30, 0x35, 0x31, 0x35, 0x32, 0x35, 0x33, 0x35, 0x34, 0x35, 0x35, //0x00000580 QUAD $0x3135303539343834; QUAD $0x3535343533353235 // .ascii 16, '4849505152535455'
0x35, 0x36, 0x35, 0x37, 0x35, 0x38, 0x35, 0x39, 0x36, 0x30, 0x36, 0x31, 0x36, 0x32, 0x36, 0x33, //0x00000590 QUAD $0x3935383537353635; QUAD $0x3336323631363036 // .ascii 16, '5657585960616263'
0x36, 0x34, 0x36, 0x35, 0x36, 0x36, 0x36, 0x37, 0x36, 0x38, 0x36, 0x39, 0x37, 0x30, 0x37, 0x31, //0x000005a0 QUAD $0x3736363635363436; QUAD $0x3137303739363836 // .ascii 16, '6465666768697071'
0x37, 0x32, 0x37, 0x33, 0x37, 0x34, 0x37, 0x35, 0x37, 0x36, 0x37, 0x37, 0x37, 0x38, 0x37, 0x39, //0x000005b0 QUAD $0x3537343733373237; QUAD $0x3937383737373637 // .ascii 16, '7273747576777879'
0x38, 0x30, 0x38, 0x31, 0x38, 0x32, 0x38, 0x33, 0x38, 0x34, 0x38, 0x35, 0x38, 0x36, 0x38, 0x37, //0x000005c0 QUAD $0x3338323831383038; QUAD $0x3738363835383438 // .ascii 16, '8081828384858687'
0x38, 0x38, 0x38, 0x39, 0x39, 0x30, 0x39, 0x31, 0x39, 0x32, 0x39, 0x33, 0x39, 0x34, 0x39, 0x35, //0x000005d0 QUAD $0x3139303939383838; QUAD $0x3539343933393239 // .ascii 16, '8889909192939495'
0x39, 0x36, 0x39, 0x37, 0x39, 0x38, 0x39, 0x39, //0x000005e0 QUAD $0x3939383937393639 // .ascii 8, '96979899'
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x000005e8 .p2align 4, 0x00
//0x000005f0 _VecShiftShuffles
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, //0x000005f0 QUAD $0x0706050403020100; QUAD $0x0f0e0d0c0b0a0908 // .ascii 16, '\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f'
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, //0x00000600 QUAD $0x0807060504030201; QUAD $0xff0f0e0d0c0b0a09 // .ascii 16, '\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff'
0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, //0x00000610 QUAD $0x0908070605040302; QUAD $0xffff0f0e0d0c0b0a // .ascii 16, '\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff'
0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, //0x00000620 QUAD $0x0a09080706050403; QUAD $0xffffff0f0e0d0c0b // .ascii 16, '\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff'
0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, 0xff, //0x00000630 QUAD $0x0b0a090807060504; QUAD $0xffffffff0f0e0d0c // .ascii 16, '\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff'
0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, //0x00000640 QUAD $0x0c0b0a0908070605; QUAD $0xffffffffff0f0e0d // .ascii 16, '\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff'
0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //0x00000650 QUAD $0x0d0c0b0a09080706; QUAD $0xffffffffffff0f0e // .ascii 16, '\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff'
0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //0x00000660 QUAD $0x0e0d0c0b0a090807; QUAD $0xffffffffffffff0f // .ascii 16, '\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff\xff'
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, //0x00000670 QUAD $0x0f0e0d0c0b0a0908; QUAD $0xffffffffffffffff // .ascii 16, '\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff\xff\xff'
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/validate_utf8_fast.go | vendor/github.com/bytedance/sonic/internal/native/sse/validate_utf8_fast.go | // 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
import (
`unsafe`
`github.com/bytedance/sonic/internal/rt`
)
var F_validate_utf8_fast func(s unsafe.Pointer) (ret int)
var S_validate_utf8_fast uintptr
//go:nosplit
func validate_utf8_fast(s *string) (ret int) {
return F_validate_utf8_fast(rt.NoEscape(unsafe.Pointer(s)))
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/lookup_small_key.go | vendor/github.com/bytedance/sonic/internal/native/sse/lookup_small_key.go | // Code generated by Makefile, DO NOT EDIT.
// 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
import (
`unsafe`
`github.com/bytedance/sonic/internal/rt`
)
var F_lookup_small_key func(key unsafe.Pointer, table unsafe.Pointer, lowerOff int) (ret int)
var S_lookup_small_key uintptr
//go:nosplit
func lookup_small_key(key *string, table *[]byte, lowerOff int) (ret int) {
return F_lookup_small_key(rt.NoEscape(unsafe.Pointer(key)), rt.NoEscape(unsafe.Pointer(table)), lowerOff)
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/f32toa_text_amd64.go | vendor/github.com/bytedance/sonic/internal/native/sse/f32toa_text_amd64.go | // +build amd64
// Code generated by asm2asm, DO NOT EDIT.
package sse
var _text_f32toa = []byte{
// .p2align 4, 0x00
// LCPI0_0
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, // QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000'
//0x00000010 .p2align 4, 0x90
//0x00000010 _f32toa
0x55, //0x00000010 pushq %rbp
0x48, 0x89, 0xe5, //0x00000011 movq %rsp, %rbp
0x41, 0x57, //0x00000014 pushq %r15
0x41, 0x56, //0x00000016 pushq %r14
0x41, 0x55, //0x00000018 pushq %r13
0x41, 0x54, //0x0000001a pushq %r12
0x53, //0x0000001c pushq %rbx
0x48, 0x83, 0xec, 0x10, //0x0000001d subq $16, %rsp
0x66, 0x0f, 0x7e, 0xc0, //0x00000021 movd %xmm0, %eax
0x89, 0xc1, //0x00000025 movl %eax, %ecx
0xc1, 0xe9, 0x17, //0x00000027 shrl $23, %ecx
0x0f, 0xb6, 0xd1, //0x0000002a movzbl %cl, %edx
0x81, 0xfa, 0xff, 0x00, 0x00, 0x00, //0x0000002d cmpl $255, %edx
0x0f, 0x84, 0x1c, 0x0e, 0x00, 0x00, //0x00000033 je LBB0_1
0xc6, 0x07, 0x2d, //0x00000039 movb $45, (%rdi)
0x41, 0x89, 0xc2, //0x0000003c movl %eax, %r10d
0x41, 0xc1, 0xea, 0x1f, //0x0000003f shrl $31, %r10d
0x4e, 0x8d, 0x0c, 0x17, //0x00000043 leaq (%rdi,%r10), %r9
0xa9, 0xff, 0xff, 0xff, 0x7f, //0x00000047 testl $2147483647, %eax
0x0f, 0x84, 0xa9, 0x01, 0x00, 0x00, //0x0000004c je LBB0_3
0x25, 0xff, 0xff, 0x7f, 0x00, //0x00000052 andl $8388607, %eax
0x85, 0xd2, //0x00000057 testl %edx, %edx
0x0f, 0x84, 0xfd, 0x0d, 0x00, 0x00, //0x00000059 je LBB0_5
0x44, 0x8d, 0x98, 0x00, 0x00, 0x80, 0x00, //0x0000005f leal $8388608(%rax), %r11d
0x44, 0x8d, 0x82, 0x6a, 0xff, 0xff, 0xff, //0x00000066 leal $-150(%rdx), %r8d
0x8d, 0x4a, 0x81, //0x0000006d leal $-127(%rdx), %ecx
0x83, 0xf9, 0x17, //0x00000070 cmpl $23, %ecx
0x0f, 0x87, 0x1c, 0x00, 0x00, 0x00, //0x00000073 ja LBB0_10
0xb9, 0x96, 0x00, 0x00, 0x00, //0x00000079 movl $150, %ecx
0x29, 0xd1, //0x0000007e subl %edx, %ecx
0x48, 0xc7, 0xc6, 0xff, 0xff, 0xff, 0xff, //0x00000080 movq $-1, %rsi
0x48, 0xd3, 0xe6, //0x00000087 shlq %cl, %rsi
0xf7, 0xd6, //0x0000008a notl %esi
0x44, 0x85, 0xde, //0x0000008c testl %r11d, %esi
0x0f, 0x84, 0x22, 0x03, 0x00, 0x00, //0x0000008f je LBB0_12
//0x00000095 LBB0_10
0x4c, 0x89, 0x4d, 0xc8, //0x00000095 movq %r9, $-56(%rbp)
0x48, 0x89, 0x7d, 0xd0, //0x00000099 movq %rdi, $-48(%rbp)
//0x0000009d LBB0_6
0x45, 0x89, 0xdf, //0x0000009d movl %r11d, %r15d
0x41, 0x83, 0xe7, 0x01, //0x000000a0 andl $1, %r15d
0x85, 0xc0, //0x000000a4 testl %eax, %eax
0x0f, 0x94, 0xc0, //0x000000a6 sete %al
0x83, 0xfa, 0x02, //0x000000a9 cmpl $2, %edx
0x0f, 0x93, 0xc1, //0x000000ac setae %cl
0x20, 0xc1, //0x000000af andb %al, %cl
0x0f, 0xb6, 0xc9, //0x000000b1 movzbl %cl, %ecx
0x45, 0x89, 0xd9, //0x000000b4 movl %r11d, %r9d
0x41, 0xc1, 0xe1, 0x02, //0x000000b7 shll $2, %r9d
0x42, 0x8d, 0x04, 0x99, //0x000000bb leal (%rcx,%r11,4), %eax
0x83, 0xc0, 0xfe, //0x000000bf addl $-2, %eax
0x41, 0x69, 0xd0, 0x13, 0x44, 0x13, 0x00, //0x000000c2 imull $1262611, %r8d, %edx
0x44, 0x8d, 0xb2, 0x01, 0x01, 0xf8, 0xff, //0x000000c9 leal $-524031(%rdx), %r14d
0x84, 0xc9, //0x000000d0 testb %cl, %cl
0x44, 0x0f, 0x44, 0xf2, //0x000000d2 cmovel %edx, %r14d
0x41, 0xc1, 0xfe, 0x16, //0x000000d6 sarl $22, %r14d
0x41, 0x69, 0xce, 0xb1, 0x6c, 0xe5, 0xff, //0x000000da imull $-1741647, %r14d, %ecx
0xc1, 0xe9, 0x13, //0x000000e1 shrl $19, %ecx
0x44, 0x01, 0xc1, //0x000000e4 addl %r8d, %ecx
0xba, 0x1f, 0x00, 0x00, 0x00, //0x000000e7 movl $31, %edx
0x44, 0x29, 0xf2, //0x000000ec subl %r14d, %edx
0x80, 0xc1, 0x01, //0x000000ef addb $1, %cl
0xd3, 0xe0, //0x000000f2 shll %cl, %eax
0x48, 0x8d, 0x35, 0x55, 0x0e, 0x00, 0x00, //0x000000f4 leaq $3669(%rip), %rsi /* _pow10_ceil_sig_f32.g+0(%rip) */
0x4c, 0x8b, 0x2c, 0xd6, //0x000000fb movq (%rsi,%rdx,8), %r13
0x49, 0xf7, 0xe5, //0x000000ff mulq %r13
0x49, 0x89, 0xd0, //0x00000102 movq %rdx, %r8
0x48, 0xc1, 0xe8, 0x20, //0x00000105 shrq $32, %rax
0x45, 0x31, 0xe4, //0x00000109 xorl %r12d, %r12d
0x83, 0xf8, 0x02, //0x0000010c cmpl $2, %eax
0x41, 0x0f, 0x93, 0xc4, //0x0000010f setae %r12b
0x41, 0xd3, 0xe1, //0x00000113 shll %cl, %r9d
0x46, 0x8d, 0x1c, 0x9d, 0x02, 0x00, 0x00, 0x00, //0x00000116 leal $2(,%r11,4), %r11d
0x4c, 0x89, 0xc8, //0x0000011e movq %r9, %rax
0x49, 0xf7, 0xe5, //0x00000121 mulq %r13
0x49, 0x89, 0xd1, //0x00000124 movq %rdx, %r9
0x45, 0x09, 0xc4, //0x00000127 orl %r8d, %r12d
0x48, 0xc1, 0xe8, 0x20, //0x0000012a shrq $32, %rax
0x31, 0xdb, //0x0000012e xorl %ebx, %ebx
0x83, 0xf8, 0x02, //0x00000130 cmpl $2, %eax
0x0f, 0x93, 0xc3, //0x00000133 setae %bl
0x41, 0xd3, 0xe3, //0x00000136 shll %cl, %r11d
0x44, 0x09, 0xcb, //0x00000139 orl %r9d, %ebx
0x4c, 0x89, 0xd8, //0x0000013c movq %r11, %rax
0x49, 0xf7, 0xe5, //0x0000013f mulq %r13
0x48, 0xc1, 0xe8, 0x20, //0x00000142 shrq $32, %rax
0x31, 0xc9, //0x00000146 xorl %ecx, %ecx
0x83, 0xf8, 0x02, //0x00000148 cmpl $2, %eax
0x0f, 0x93, 0xc1, //0x0000014b setae %cl
0x09, 0xd1, //0x0000014e orl %edx, %ecx
0x45, 0x01, 0xfc, //0x00000150 addl %r15d, %r12d
0x44, 0x29, 0xf9, //0x00000153 subl %r15d, %ecx
0x83, 0xfb, 0x28, //0x00000156 cmpl $40, %ebx
0x0f, 0x82, 0x42, 0x00, 0x00, 0x00, //0x00000159 jb LBB0_31
0x44, 0x89, 0xc8, //0x0000015f movl %r9d, %eax
0xba, 0xcd, 0xcc, 0xcc, 0xcc, //0x00000162 movl $3435973837, %edx
0x48, 0x0f, 0xaf, 0xd0, //0x00000167 imulq %rax, %rdx
0x48, 0xc1, 0xea, 0x25, //0x0000016b shrq $37, %rdx
0x44, 0x89, 0xe0, //0x0000016f movl %r12d, %eax
0x48, 0x8d, 0x34, 0xd5, 0x00, 0x00, 0x00, 0x00, //0x00000172 leaq (,%rdx,8), %rsi
0x48, 0x8d, 0x3c, 0xb6, //0x0000017a leaq (%rsi,%rsi,4), %rdi
0x48, 0x39, 0xc7, //0x0000017e cmpq %rax, %rdi
0x41, 0x0f, 0x92, 0xc3, //0x00000181 setb %r11b
0x48, 0x8d, 0x34, 0xb6, //0x00000185 leaq (%rsi,%rsi,4), %rsi
0x48, 0x83, 0xc6, 0x28, //0x00000189 addq $40, %rsi
0x89, 0xcf, //0x0000018d movl %ecx, %edi
0x31, 0xc0, //0x0000018f xorl %eax, %eax
0x48, 0x39, 0xfe, //0x00000191 cmpq %rdi, %rsi
0x41, 0x0f, 0x96, 0xc0, //0x00000194 setbe %r8b
0x45, 0x38, 0xc3, //0x00000198 cmpb %r8b, %r11b
0x0f, 0x84, 0xb7, 0x00, 0x00, 0x00, //0x0000019b je LBB0_8
//0x000001a1 LBB0_31
0x4d, 0x89, 0xc8, //0x000001a1 movq %r9, %r8
0x49, 0xc1, 0xe8, 0x02, //0x000001a4 shrq $2, %r8
0x44, 0x89, 0xca, //0x000001a8 movl %r9d, %edx
0x83, 0xe2, 0xfc, //0x000001ab andl $-4, %edx
0x41, 0x39, 0xd4, //0x000001ae cmpl %edx, %r12d
0x40, 0x0f, 0x97, 0xc6, //0x000001b1 seta %sil
0x8d, 0x7a, 0x04, //0x000001b5 leal $4(%rdx), %edi
0x39, 0xcf, //0x000001b8 cmpl %ecx, %edi
0x0f, 0x96, 0xc0, //0x000001ba setbe %al
0x40, 0x30, 0xf0, //0x000001bd xorb %sil, %al
0x0f, 0x84, 0x48, 0x00, 0x00, 0x00, //0x000001c0 je LBB0_32
0x83, 0xca, 0x02, //0x000001c6 orl $2, %edx
0xb8, 0x01, 0x00, 0x00, 0x00, //0x000001c9 movl $1, %eax
0x39, 0xd3, //0x000001ce cmpl %edx, %ebx
0x4c, 0x8b, 0x65, 0xc8, //0x000001d0 movq $-56(%rbp), %r12
0x0f, 0x87, 0x0e, 0x00, 0x00, 0x00, //0x000001d4 ja LBB0_35
0x0f, 0x94, 0xc0, //0x000001da sete %al
0x41, 0xc0, 0xe9, 0x02, //0x000001dd shrb $2, %r9b
0x41, 0x20, 0xc1, //0x000001e1 andb %al, %r9b
0x41, 0x0f, 0xb6, 0xc1, //0x000001e4 movzbl %r9b, %eax
//0x000001e8 LBB0_35
0x44, 0x01, 0xc0, //0x000001e8 addl %r8d, %eax
0x3d, 0xa0, 0x86, 0x01, 0x00, //0x000001eb cmpl $100000, %eax
0x0f, 0x83, 0x30, 0x00, 0x00, 0x00, //0x000001f0 jae LBB0_37
0xe9, 0x75, 0x00, 0x00, 0x00, //0x000001f6 jmp LBB0_40
//0x000001fb LBB0_3
0x41, 0xc6, 0x01, 0x30, //0x000001fb movb $48, (%r9)
0x41, 0x29, 0xf9, //0x000001ff subl %edi, %r9d
0x41, 0x83, 0xc1, 0x01, //0x00000202 addl $1, %r9d
0x44, 0x89, 0xc8, //0x00000206 movl %r9d, %eax
0xe9, 0x38, 0x0c, 0x00, 0x00, //0x00000209 jmp LBB0_156
//0x0000020e LBB0_32
0x39, 0xf9, //0x0000020e cmpl %edi, %ecx
0x41, 0x83, 0xd8, 0xff, //0x00000210 sbbl $-1, %r8d
0x44, 0x89, 0xc0, //0x00000214 movl %r8d, %eax
0x4c, 0x8b, 0x65, 0xc8, //0x00000217 movq $-56(%rbp), %r12
0x3d, 0xa0, 0x86, 0x01, 0x00, //0x0000021b cmpl $100000, %eax
0x0f, 0x82, 0x4a, 0x00, 0x00, 0x00, //0x00000220 jb LBB0_40
//0x00000226 LBB0_37
0x41, 0xbd, 0x06, 0x00, 0x00, 0x00, //0x00000226 movl $6, %r13d
0x3d, 0x40, 0x42, 0x0f, 0x00, //0x0000022c cmpl $1000000, %eax
0x0f, 0x82, 0x77, 0x00, 0x00, 0x00, //0x00000231 jb LBB0_45
0x41, 0xbd, 0x07, 0x00, 0x00, 0x00, //0x00000237 movl $7, %r13d
0x3d, 0x80, 0x96, 0x98, 0x00, //0x0000023d cmpl $10000000, %eax
0x0f, 0x82, 0x66, 0x00, 0x00, 0x00, //0x00000242 jb LBB0_45
0x3d, 0x00, 0xe1, 0xf5, 0x05, //0x00000248 cmpl $100000000, %eax
0x41, 0xbd, 0x09, 0x00, 0x00, 0x00, //0x0000024d movl $9, %r13d
0xe9, 0x52, 0x00, 0x00, 0x00, //0x00000253 jmp LBB0_44
//0x00000258 LBB0_8
0x44, 0x88, 0xc0, //0x00000258 movb %r8b, %al
0x01, 0xd0, //0x0000025b addl %edx, %eax
0x41, 0x83, 0xc6, 0x01, //0x0000025d addl $1, %r14d
0x4c, 0x8b, 0x65, 0xc8, //0x00000261 movq $-56(%rbp), %r12
0x3d, 0xa0, 0x86, 0x01, 0x00, //0x00000265 cmpl $100000, %eax
0x0f, 0x83, 0xb6, 0xff, 0xff, 0xff, //0x0000026a jae LBB0_37
//0x00000270 LBB0_40
0x41, 0xbd, 0x01, 0x00, 0x00, 0x00, //0x00000270 movl $1, %r13d
0x83, 0xf8, 0x0a, //0x00000276 cmpl $10, %eax
0x0f, 0x82, 0x2f, 0x00, 0x00, 0x00, //0x00000279 jb LBB0_45
0x41, 0xbd, 0x02, 0x00, 0x00, 0x00, //0x0000027f movl $2, %r13d
0x83, 0xf8, 0x64, //0x00000285 cmpl $100, %eax
0x0f, 0x82, 0x20, 0x00, 0x00, 0x00, //0x00000288 jb LBB0_45
0x41, 0xbd, 0x03, 0x00, 0x00, 0x00, //0x0000028e movl $3, %r13d
0x3d, 0xe8, 0x03, 0x00, 0x00, //0x00000294 cmpl $1000, %eax
0x0f, 0x82, 0x0f, 0x00, 0x00, 0x00, //0x00000299 jb LBB0_45
0x3d, 0x10, 0x27, 0x00, 0x00, //0x0000029f cmpl $10000, %eax
0x41, 0xbd, 0x05, 0x00, 0x00, 0x00, //0x000002a4 movl $5, %r13d
//0x000002aa LBB0_44
0x41, 0x83, 0xdd, 0x00, //0x000002aa sbbl $0, %r13d
//0x000002ae LBB0_45
0x47, 0x8d, 0x0c, 0x2e, //0x000002ae leal (%r14,%r13), %r9d
0x43, 0x8d, 0x0c, 0x2e, //0x000002b2 leal (%r14,%r13), %ecx
0x83, 0xc1, 0x05, //0x000002b6 addl $5, %ecx
0x83, 0xf9, 0x1b, //0x000002b9 cmpl $27, %ecx
0x0f, 0x82, 0x6d, 0x00, 0x00, 0x00, //0x000002bc jb LBB0_70
0x44, 0x89, 0xea, //0x000002c2 movl %r13d, %edx
0x49, 0x8d, 0x0c, 0x14, //0x000002c5 leaq (%r12,%rdx), %rcx
0x48, 0x83, 0xc1, 0x01, //0x000002c9 addq $1, %rcx
0x3d, 0x10, 0x27, 0x00, 0x00, //0x000002cd cmpl $10000, %eax
0x0f, 0x82, 0xc6, 0x00, 0x00, 0x00, //0x000002d2 jb LBB0_47
0x89, 0xc6, //0x000002d8 movl %eax, %esi
0xbb, 0x59, 0x17, 0xb7, 0xd1, //0x000002da movl $3518437209, %ebx
0x48, 0x0f, 0xaf, 0xde, //0x000002df imulq %rsi, %rbx
0x48, 0xc1, 0xeb, 0x2d, //0x000002e3 shrq $45, %rbx
0x44, 0x69, 0xc3, 0xf0, 0xd8, 0xff, 0xff, //0x000002e7 imull $-10000, %ebx, %r8d
0x41, 0x01, 0xc0, //0x000002ee addl %eax, %r8d
0x4c, 0x8b, 0x6d, 0xd0, //0x000002f1 movq $-48(%rbp), %r13
0x0f, 0x84, 0x48, 0x03, 0x00, 0x00, //0x000002f5 je LBB0_49
0x44, 0x89, 0xc0, //0x000002fb movl %r8d, %eax
0x48, 0x69, 0xc0, 0x1f, 0x85, 0xeb, 0x51, //0x000002fe imulq $1374389535, %rax, %rax
0x48, 0xc1, 0xe8, 0x25, //0x00000305 shrq $37, %rax
0x6b, 0xf0, 0x64, //0x00000309 imull $100, %eax, %esi
0x41, 0x29, 0xf0, //0x0000030c subl %esi, %r8d
0x48, 0x8d, 0x35, 0x6a, 0x0b, 0x00, 0x00, //0x0000030f leaq $2922(%rip), %rsi /* _Digits+0(%rip) */
0x42, 0x0f, 0xb7, 0x3c, 0x46, //0x00000316 movzwl (%rsi,%r8,2), %edi
0x66, 0x89, 0x79, 0xfe, //0x0000031b movw %di, $-2(%rcx)
0x0f, 0xb7, 0x04, 0x46, //0x0000031f movzwl (%rsi,%rax,2), %eax
0x66, 0x89, 0x41, 0xfc, //0x00000323 movw %ax, $-4(%rcx)
0x45, 0x31, 0xc0, //0x00000327 xorl %r8d, %r8d
0xe9, 0x1a, 0x03, 0x00, 0x00, //0x0000032a jmp LBB0_51
//0x0000032f LBB0_70
0x45, 0x89, 0xe8, //0x0000032f movl %r13d, %r8d
0x45, 0x85, 0xf6, //0x00000332 testl %r14d, %r14d
0x0f, 0x88, 0x1c, 0x01, 0x00, 0x00, //0x00000335 js LBB0_71
0x4b, 0x8d, 0x14, 0x04, //0x0000033b leaq (%r12,%r8), %rdx
0x3d, 0x10, 0x27, 0x00, 0x00, //0x0000033f cmpl $10000, %eax
0x0f, 0x82, 0x77, 0x01, 0x00, 0x00, //0x00000344 jb LBB0_124
0x89, 0xc1, //0x0000034a movl %eax, %ecx
0xbe, 0x59, 0x17, 0xb7, 0xd1, //0x0000034c movl $3518437209, %esi
0x48, 0x0f, 0xaf, 0xf1, //0x00000351 imulq %rcx, %rsi
0x48, 0xc1, 0xee, 0x2d, //0x00000355 shrq $45, %rsi
0x69, 0xce, 0xf0, 0xd8, 0xff, 0xff, //0x00000359 imull $-10000, %esi, %ecx
0x01, 0xc1, //0x0000035f addl %eax, %ecx
0x48, 0x69, 0xc1, 0x1f, 0x85, 0xeb, 0x51, //0x00000361 imulq $1374389535, %rcx, %rax
0x48, 0xc1, 0xe8, 0x25, //0x00000368 shrq $37, %rax
0x6b, 0xf8, 0x64, //0x0000036c imull $100, %eax, %edi
0x29, 0xf9, //0x0000036f subl %edi, %ecx
0x48, 0x8d, 0x3d, 0x08, 0x0b, 0x00, 0x00, //0x00000371 leaq $2824(%rip), %rdi /* _Digits+0(%rip) */
0x0f, 0xb7, 0x0c, 0x4f, //0x00000378 movzwl (%rdi,%rcx,2), %ecx
0x66, 0x89, 0x4a, 0xfe, //0x0000037c movw %cx, $-2(%rdx)
0x48, 0x8d, 0x4a, 0xfc, //0x00000380 leaq $-4(%rdx), %rcx
0x0f, 0xb7, 0x04, 0x47, //0x00000384 movzwl (%rdi,%rax,2), %eax
0x66, 0x89, 0x42, 0xfc, //0x00000388 movw %ax, $-4(%rdx)
0x89, 0xf0, //0x0000038c movl %esi, %eax
0x83, 0xf8, 0x64, //0x0000038e cmpl $100, %eax
0x0f, 0x83, 0x36, 0x01, 0x00, 0x00, //0x00000391 jae LBB0_128
//0x00000397 LBB0_127
0x89, 0xc3, //0x00000397 movl %eax, %ebx
0xe9, 0x70, 0x01, 0x00, 0x00, //0x00000399 jmp LBB0_130
//0x0000039e LBB0_47
0x45, 0x31, 0xc0, //0x0000039e xorl %r8d, %r8d
0x89, 0xc3, //0x000003a1 movl %eax, %ebx
0x4c, 0x8b, 0x6d, 0xd0, //0x000003a3 movq $-48(%rbp), %r13
0x83, 0xfb, 0x64, //0x000003a7 cmpl $100, %ebx
0x0f, 0x83, 0xa6, 0x02, 0x00, 0x00, //0x000003aa jae LBB0_54
//0x000003b0 LBB0_53
0x89, 0xd8, //0x000003b0 movl %ebx, %eax
0xe9, 0xe8, 0x02, 0x00, 0x00, //0x000003b2 jmp LBB0_56
//0x000003b7 LBB0_12
0x41, 0xd3, 0xeb, //0x000003b7 shrl %cl, %r11d
0x41, 0x81, 0xfb, 0xa0, 0x86, 0x01, 0x00, //0x000003ba cmpl $100000, %r11d
0x0f, 0x82, 0xc8, 0x01, 0x00, 0x00, //0x000003c1 jb LBB0_18
0xb9, 0x06, 0x00, 0x00, 0x00, //0x000003c7 movl $6, %ecx
0x41, 0x81, 0xfb, 0x40, 0x42, 0x0f, 0x00, //0x000003cc cmpl $1000000, %r11d
0x0f, 0x82, 0x22, 0x00, 0x00, 0x00, //0x000003d3 jb LBB0_16
0xb9, 0x07, 0x00, 0x00, 0x00, //0x000003d9 movl $7, %ecx
0x41, 0x81, 0xfb, 0x80, 0x96, 0x98, 0x00, //0x000003de cmpl $10000000, %r11d
0x0f, 0x82, 0x10, 0x00, 0x00, 0x00, //0x000003e5 jb LBB0_16
0x41, 0x81, 0xfb, 0x00, 0xe1, 0xf5, 0x05, //0x000003eb cmpl $100000000, %r11d
0xb9, 0x09, 0x00, 0x00, 0x00, //0x000003f2 movl $9, %ecx
0x48, 0x83, 0xd9, 0x00, //0x000003f7 sbbq $0, %rcx
//0x000003fb LBB0_16
0x4c, 0x01, 0xc9, //0x000003fb addq %r9, %rcx
//0x000003fe LBB0_17
0x44, 0x89, 0xd8, //0x000003fe movl %r11d, %eax
0xba, 0x59, 0x17, 0xb7, 0xd1, //0x00000401 movl $3518437209, %edx
0x48, 0x0f, 0xaf, 0xd0, //0x00000406 imulq %rax, %rdx
0x48, 0xc1, 0xea, 0x2d, //0x0000040a shrq $45, %rdx
0x69, 0xc2, 0xf0, 0xd8, 0xff, 0xff, //0x0000040e imull $-10000, %edx, %eax
0x44, 0x01, 0xd8, //0x00000414 addl %r11d, %eax
0x48, 0x69, 0xf0, 0x1f, 0x85, 0xeb, 0x51, //0x00000417 imulq $1374389535, %rax, %rsi
0x48, 0xc1, 0xee, 0x25, //0x0000041e shrq $37, %rsi
0x6b, 0xde, 0x64, //0x00000422 imull $100, %esi, %ebx
0x29, 0xd8, //0x00000425 subl %ebx, %eax
0x48, 0x8d, 0x1d, 0x52, 0x0a, 0x00, 0x00, //0x00000427 leaq $2642(%rip), %rbx /* _Digits+0(%rip) */
0x0f, 0xb7, 0x04, 0x43, //0x0000042e movzwl (%rbx,%rax,2), %eax
0x66, 0x89, 0x41, 0xfe, //0x00000432 movw %ax, $-2(%rcx)
0x0f, 0xb7, 0x04, 0x73, //0x00000436 movzwl (%rbx,%rsi,2), %eax
0x66, 0x89, 0x41, 0xfc, //0x0000043a movw %ax, $-4(%rcx)
0x48, 0x89, 0xc8, //0x0000043e movq %rcx, %rax
0x48, 0x83, 0xc1, 0xfc, //0x00000441 addq $-4, %rcx
0x41, 0x89, 0xd3, //0x00000445 movl %edx, %r11d
0x41, 0x83, 0xfb, 0x64, //0x00000448 cmpl $100, %r11d
0x0f, 0x83, 0x7d, 0x01, 0x00, 0x00, //0x0000044c jae LBB0_25
0xe9, 0xbb, 0x01, 0x00, 0x00, //0x00000452 jmp LBB0_27
//0x00000457 LBB0_71
0x45, 0x85, 0xc9, //0x00000457 testl %r9d, %r9d
0x0f, 0x8f, 0x22, 0x06, 0x00, 0x00, //0x0000045a jg LBB0_84
0x66, 0x41, 0xc7, 0x04, 0x24, 0x30, 0x2e, //0x00000460 movw $11824, (%r12)
0x49, 0x83, 0xc4, 0x02, //0x00000467 addq $2, %r12
0x45, 0x85, 0xc9, //0x0000046b testl %r9d, %r9d
0x0f, 0x89, 0x0e, 0x06, 0x00, 0x00, //0x0000046e jns LBB0_84
0x45, 0x89, 0xeb, //0x00000474 movl %r13d, %r11d
0x41, 0xf7, 0xd3, //0x00000477 notl %r11d
0x45, 0x29, 0xf3, //0x0000047a subl %r14d, %r11d
0x31, 0xc9, //0x0000047d xorl %ecx, %ecx
0x41, 0x83, 0xfb, 0x1f, //0x0000047f cmpl $31, %r11d
0x0f, 0x82, 0xe0, 0x05, 0x00, 0x00, //0x00000483 jb LBB0_82
0x4c, 0x89, 0xe7, //0x00000489 movq %r12, %rdi
0x49, 0x83, 0xc3, 0x01, //0x0000048c addq $1, %r11
0x4c, 0x89, 0xd9, //0x00000490 movq %r11, %rcx
0x48, 0x83, 0xe1, 0xe0, //0x00000493 andq $-32, %rcx
0x48, 0x8d, 0x51, 0xe0, //0x00000497 leaq $-32(%rcx), %rdx
0x49, 0x89, 0xd4, //0x0000049b movq %rdx, %r12
0x49, 0xc1, 0xec, 0x05, //0x0000049e shrq $5, %r12
0x49, 0x83, 0xc4, 0x01, //0x000004a2 addq $1, %r12
0x45, 0x89, 0xe7, //0x000004a6 movl %r12d, %r15d
0x41, 0x83, 0xe7, 0x07, //0x000004a9 andl $7, %r15d
0x48, 0x81, 0xfa, 0xe0, 0x00, 0x00, 0x00, //0x000004ad cmpq $224, %rdx
0x0f, 0x83, 0xbe, 0x04, 0x00, 0x00, //0x000004b4 jae LBB0_76
0x31, 0xd2, //0x000004ba xorl %edx, %edx
0xe9, 0x5c, 0x05, 0x00, 0x00, //0x000004bc jmp LBB0_78
//0x000004c1 LBB0_124
0x48, 0x89, 0xd1, //0x000004c1 movq %rdx, %rcx
0x83, 0xf8, 0x64, //0x000004c4 cmpl $100, %eax
0x0f, 0x82, 0xca, 0xfe, 0xff, 0xff, //0x000004c7 jb LBB0_127
//0x000004cd LBB0_128
0x48, 0x83, 0xc1, 0xff, //0x000004cd addq $-1, %rcx
0x4c, 0x8d, 0x1d, 0xa8, 0x09, 0x00, 0x00, //0x000004d1 leaq $2472(%rip), %r11 /* _Digits+0(%rip) */
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x000004d8 .p2align 4, 0x90
//0x000004e0 LBB0_129
0x89, 0xc6, //0x000004e0 movl %eax, %esi
0x48, 0x69, 0xde, 0x1f, 0x85, 0xeb, 0x51, //0x000004e2 imulq $1374389535, %rsi, %rbx
0x48, 0xc1, 0xeb, 0x25, //0x000004e9 shrq $37, %rbx
0x6b, 0xf3, 0x64, //0x000004ed imull $100, %ebx, %esi
0x89, 0xc7, //0x000004f0 movl %eax, %edi
0x29, 0xf7, //0x000004f2 subl %esi, %edi
0x41, 0x0f, 0xb7, 0x34, 0x7b, //0x000004f4 movzwl (%r11,%rdi,2), %esi
0x66, 0x89, 0x71, 0xff, //0x000004f9 movw %si, $-1(%rcx)
0x48, 0x83, 0xc1, 0xfe, //0x000004fd addq $-2, %rcx
0x3d, 0x0f, 0x27, 0x00, 0x00, //0x00000501 cmpl $9999, %eax
0x89, 0xd8, //0x00000506 movl %ebx, %eax
0x0f, 0x87, 0xd2, 0xff, 0xff, 0xff, //0x00000508 ja LBB0_129
//0x0000050e LBB0_130
0x4d, 0x63, 0xe9, //0x0000050e movslq %r9d, %r13
0x83, 0xfb, 0x0a, //0x00000511 cmpl $10, %ebx
0x0f, 0x82, 0x23, 0x00, 0x00, 0x00, //0x00000514 jb LBB0_132
0x89, 0xd8, //0x0000051a movl %ebx, %eax
0x48, 0x8d, 0x0d, 0x5d, 0x09, 0x00, 0x00, //0x0000051c leaq $2397(%rip), %rcx /* _Digits+0(%rip) */
0x0f, 0xb7, 0x04, 0x41, //0x00000523 movzwl (%rcx,%rax,2), %eax
0x66, 0x41, 0x89, 0x04, 0x24, //0x00000527 movw %ax, (%r12)
0x4d, 0x01, 0xec, //0x0000052c addq %r13, %r12
0x4d, 0x39, 0xe8, //0x0000052f cmpq %r13, %r8
0x0f, 0x8c, 0x18, 0x00, 0x00, 0x00, //0x00000532 jl LBB0_135
0xe9, 0xdd, 0x03, 0x00, 0x00, //0x00000538 jmp LBB0_134
//0x0000053d LBB0_132
0x80, 0xc3, 0x30, //0x0000053d addb $48, %bl
0x41, 0x88, 0x1c, 0x24, //0x00000540 movb %bl, (%r12)
0x4d, 0x01, 0xec, //0x00000544 addq %r13, %r12
0x4d, 0x39, 0xe8, //0x00000547 cmpq %r13, %r8
0x0f, 0x8d, 0xca, 0x03, 0x00, 0x00, //0x0000054a jge LBB0_134
//0x00000550 LBB0_135
0x48, 0x8b, 0x45, 0xd0, //0x00000550 movq $-48(%rbp), %rax
0x4c, 0x01, 0xd0, //0x00000554 addq %r10, %rax
0x4d, 0x8d, 0x34, 0x00, //0x00000557 leaq (%r8,%rax), %r14
0x49, 0x83, 0xc6, 0x01, //0x0000055b addq $1, %r14
0x49, 0x01, 0xc5, //0x0000055f addq %rax, %r13
0x4d, 0x39, 0xee, //0x00000562 cmpq %r13, %r14
0x4d, 0x89, 0xef, //0x00000565 movq %r13, %r15
0x4d, 0x0f, 0x47, 0xfe, //0x00000568 cmovaq %r14, %r15
0x4e, 0x8d, 0x1c, 0x00, //0x0000056c leaq (%rax,%r8), %r11
0x4d, 0x29, 0xdf, //0x00000570 subq %r11, %r15
0x49, 0x83, 0xff, 0x08, //0x00000573 cmpq $8, %r15
0x0f, 0x82, 0xd3, 0x03, 0x00, 0x00, //0x00000577 jb LBB0_152
0x49, 0x83, 0xff, 0x20, //0x0000057d cmpq $32, %r15
0x0f, 0x83, 0xfb, 0x01, 0x00, 0x00, //0x00000581 jae LBB0_141
0x45, 0x31, 0xc9, //0x00000587 xorl %r9d, %r9d
0xe9, 0x3b, 0x03, 0x00, 0x00, //0x0000058a jmp LBB0_138
//0x0000058f LBB0_18
0xb8, 0x01, 0x00, 0x00, 0x00, //0x0000058f movl $1, %eax
0x41, 0x83, 0xfb, 0x0a, //0x00000594 cmpl $10, %r11d
0x0f, 0x82, 0x21, 0x00, 0x00, 0x00, //0x00000598 jb LBB0_21
0xb8, 0x02, 0x00, 0x00, 0x00, //0x0000059e movl $2, %eax
0x41, 0x83, 0xfb, 0x64, //0x000005a3 cmpl $100, %r11d
0x0f, 0x82, 0x12, 0x00, 0x00, 0x00, //0x000005a7 jb LBB0_21
0xb8, 0x03, 0x00, 0x00, 0x00, //0x000005ad movl $3, %eax
0x41, 0x81, 0xfb, 0xe8, 0x03, 0x00, 0x00, //0x000005b2 cmpl $1000, %r11d
0x0f, 0x83, 0x67, 0x03, 0x00, 0x00, //0x000005b9 jae LBB0_23
//0x000005bf LBB0_21
0x4c, 0x01, 0xc8, //0x000005bf addq %r9, %rax
0x48, 0x89, 0xc1, //0x000005c2 movq %rax, %rcx
0x41, 0x83, 0xfb, 0x64, //0x000005c5 cmpl $100, %r11d
0x0f, 0x82, 0x43, 0x00, 0x00, 0x00, //0x000005c9 jb LBB0_27
//0x000005cf LBB0_25
0x48, 0x83, 0xc1, 0xff, //0x000005cf addq $-1, %rcx
0x4c, 0x8d, 0x05, 0xa6, 0x08, 0x00, 0x00, //0x000005d3 leaq $2214(%rip), %r8 /* _Digits+0(%rip) */
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x000005da .p2align 4, 0x90
//0x000005e0 LBB0_26
0x44, 0x89, 0xde, //0x000005e0 movl %r11d, %esi
0x44, 0x89, 0xdb, //0x000005e3 movl %r11d, %ebx
0x4c, 0x69, 0xdb, 0x1f, 0x85, 0xeb, 0x51, //0x000005e6 imulq $1374389535, %rbx, %r11
0x49, 0xc1, 0xeb, 0x25, //0x000005ed shrq $37, %r11
0x41, 0x6b, 0xdb, 0x64, //0x000005f1 imull $100, %r11d, %ebx
0x89, 0xf2, //0x000005f5 movl %esi, %edx
0x29, 0xda, //0x000005f7 subl %ebx, %edx
0x41, 0x0f, 0xb7, 0x14, 0x50, //0x000005f9 movzwl (%r8,%rdx,2), %edx
0x66, 0x89, 0x51, 0xff, //0x000005fe movw %dx, $-1(%rcx)
0x48, 0x83, 0xc1, 0xfe, //0x00000602 addq $-2, %rcx
0x81, 0xfe, 0x0f, 0x27, 0x00, 0x00, //0x00000606 cmpl $9999, %esi
0x0f, 0x87, 0xce, 0xff, 0xff, 0xff, //0x0000060c ja LBB0_26
//0x00000612 LBB0_27
0x41, 0x83, 0xfb, 0x0a, //0x00000612 cmpl $10, %r11d
0x0f, 0x82, 0x19, 0x00, 0x00, 0x00, //0x00000616 jb LBB0_29
0x44, 0x89, 0xd9, //0x0000061c movl %r11d, %ecx
0x48, 0x8d, 0x15, 0x5a, 0x08, 0x00, 0x00, //0x0000061f leaq $2138(%rip), %rdx /* _Digits+0(%rip) */
0x0f, 0xb7, 0x0c, 0x4a, //0x00000626 movzwl (%rdx,%rcx,2), %ecx
0x66, 0x41, 0x89, 0x09, //0x0000062a movw %cx, (%r9)
0x29, 0xf8, //0x0000062e subl %edi, %eax
0xe9, 0x11, 0x08, 0x00, 0x00, //0x00000630 jmp LBB0_156
//0x00000635 LBB0_29
0x41, 0x80, 0xc3, 0x30, //0x00000635 addb $48, %r11b
0x45, 0x88, 0x19, //0x00000639 movb %r11b, (%r9)
0x29, 0xf8, //0x0000063c subl %edi, %eax
0xe9, 0x03, 0x08, 0x00, 0x00, //0x0000063e jmp LBB0_156
//0x00000643 LBB0_49
0x41, 0xb8, 0x04, 0x00, 0x00, 0x00, //0x00000643 movl $4, %r8d
//0x00000649 LBB0_51
0x48, 0x83, 0xc1, 0xfc, //0x00000649 addq $-4, %rcx
0x83, 0xfb, 0x64, //0x0000064d cmpl $100, %ebx
0x0f, 0x82, 0x5a, 0xfd, 0xff, 0xff, //0x00000650 jb LBB0_53
//0x00000656 LBB0_54
0x48, 0x83, 0xc1, 0xff, //0x00000656 addq $-1, %rcx
0x4c, 0x8d, 0x1d, 0x1f, 0x08, 0x00, 0x00, //0x0000065a leaq $2079(%rip), %r11 /* _Digits+0(%rip) */
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000661 .p2align 4, 0x90
//0x00000670 LBB0_55
0x89, 0xd8, //0x00000670 movl %ebx, %eax
0x48, 0x69, 0xc0, 0x1f, 0x85, 0xeb, 0x51, //0x00000672 imulq $1374389535, %rax, %rax
0x48, 0xc1, 0xe8, 0x25, //0x00000679 shrq $37, %rax
0x6b, 0xf0, 0x64, //0x0000067d imull $100, %eax, %esi
0x89, 0xdf, //0x00000680 movl %ebx, %edi
0x29, 0xf7, //0x00000682 subl %esi, %edi
0x41, 0x0f, 0xb7, 0x34, 0x7b, //0x00000684 movzwl (%r11,%rdi,2), %esi
0x66, 0x89, 0x71, 0xff, //0x00000689 movw %si, $-1(%rcx)
0x48, 0x83, 0xc1, 0xfe, //0x0000068d addq $-2, %rcx
0x81, 0xfb, 0x0f, 0x27, 0x00, 0x00, //0x00000691 cmpl $9999, %ebx
0x89, 0xc3, //0x00000697 movl %eax, %ebx
0x0f, 0x87, 0xd1, 0xff, 0xff, 0xff, //0x00000699 ja LBB0_55
//0x0000069f LBB0_56
0x49, 0x8d, 0x4c, 0x24, 0x01, //0x0000069f leaq $1(%r12), %rcx
0x83, 0xf8, 0x0a, //0x000006a4 cmpl $10, %eax
0x0f, 0x82, 0x1f, 0x00, 0x00, 0x00, //0x000006a7 jb LBB0_58
0x89, 0xc6, //0x000006ad movl %eax, %esi
0x48, 0x8d, 0x3d, 0xca, 0x07, 0x00, 0x00, //0x000006af leaq $1994(%rip), %rdi /* _Digits+0(%rip) */
0x8a, 0x04, 0x77, //0x000006b6 movb (%rdi,%rsi,2), %al
0x8a, 0x5c, 0x77, 0x01, //0x000006b9 movb $1(%rdi,%rsi,2), %bl
0x41, 0x88, 0x44, 0x24, 0x01, //0x000006bd movb %al, $1(%r12)
0x41, 0x88, 0x5c, 0x24, 0x02, //0x000006c2 movb %bl, $2(%r12)
0xe9, 0x04, 0x00, 0x00, 0x00, //0x000006c7 jmp LBB0_59
//0x000006cc LBB0_58
0x04, 0x30, //0x000006cc addb $48, %al
0x88, 0x01, //0x000006ce movb %al, (%rcx)
//0x000006d0 LBB0_59
0x4d, 0x29, 0xc2, //0x000006d0 subq %r8, %r10
0x4d, 0x01, 0xea, //0x000006d3 addq %r13, %r10
0xbb, 0x01, 0x00, 0x00, 0x00, //0x000006d6 movl $1, %ebx
0x4c, 0x29, 0xc3, //0x000006db subq %r8, %rbx
0x90, 0x90, //0x000006de .p2align 4, 0x90
//0x000006e0 LBB0_60
0x48, 0x83, 0xc3, 0xff, //0x000006e0 addq $-1, %rbx
0x41, 0x80, 0x3c, 0x12, 0x30, //0x000006e4 cmpb $48, (%r10,%rdx)
0x4d, 0x8d, 0x52, 0xff, //0x000006e9 leaq $-1(%r10), %r10
0x0f, 0x84, 0xed, 0xff, 0xff, 0xff, //0x000006ed je LBB0_60
0x41, 0x88, 0x04, 0x24, //0x000006f3 movb %al, (%r12)
0x48, 0x01, 0xd3, //0x000006f7 addq %rdx, %rbx
0x48, 0x83, 0xfb, 0x02, //0x000006fa cmpq $2, %rbx
0x0f, 0x8c, 0x46, 0x00, 0x00, 0x00, //0x000006fe jl LBB0_62
0x49, 0x8d, 0x04, 0x12, //0x00000704 leaq (%r10,%rdx), %rax
0x48, 0x83, 0xc0, 0x02, //0x00000708 addq $2, %rax
0xc6, 0x01, 0x2e, //0x0000070c movb $46, (%rcx)
0xc6, 0x00, 0x65, //0x0000070f movb $101, (%rax)
0x45, 0x85, 0xc9, //0x00000712 testl %r9d, %r9d
0x0f, 0x8e, 0x43, 0x00, 0x00, 0x00, //0x00000715 jle LBB0_65
//0x0000071b LBB0_66
0x41, 0x83, 0xc1, 0xff, //0x0000071b addl $-1, %r9d
0xc6, 0x40, 0x01, 0x2b, //0x0000071f movb $43, $1(%rax)
0x44, 0x89, 0xc9, //0x00000723 movl %r9d, %ecx
0x83, 0xf9, 0x0a, //0x00000726 cmpl $10, %ecx
0x0f, 0x8c, 0x44, 0x00, 0x00, 0x00, //0x00000729 jl LBB0_69
//0x0000072f LBB0_68
0x48, 0x63, 0xc9, //0x0000072f movslq %ecx, %rcx
0x48, 0x8d, 0x15, 0x47, 0x07, 0x00, 0x00, //0x00000732 leaq $1863(%rip), %rdx /* _Digits+0(%rip) */
0x0f, 0xb7, 0x0c, 0x4a, //0x00000739 movzwl (%rdx,%rcx,2), %ecx
0x66, 0x89, 0x48, 0x02, //0x0000073d movw %cx, $2(%rax)
0x48, 0x83, 0xc0, 0x04, //0x00000741 addq $4, %rax
0xe9, 0xf9, 0x06, 0x00, 0x00, //0x00000745 jmp LBB0_155
//0x0000074a LBB0_62
0x49, 0x8d, 0x04, 0x12, //0x0000074a leaq (%r10,%rdx), %rax
0x48, 0x83, 0xc0, 0x01, //0x0000074e addq $1, %rax
0xc6, 0x00, 0x65, //0x00000752 movb $101, (%rax)
0x45, 0x85, 0xc9, //0x00000755 testl %r9d, %r9d
0x0f, 0x8f, 0xbd, 0xff, 0xff, 0xff, //0x00000758 jg LBB0_66
//0x0000075e LBB0_65
0xc6, 0x40, 0x01, 0x2d, //0x0000075e movb $45, $1(%rax)
0xb9, 0x01, 0x00, 0x00, 0x00, //0x00000762 movl $1, %ecx
0x44, 0x29, 0xc9, //0x00000767 subl %r9d, %ecx
0x83, 0xf9, 0x0a, //0x0000076a cmpl $10, %ecx
0x0f, 0x8d, 0xbc, 0xff, 0xff, 0xff, //0x0000076d jge LBB0_68
//0x00000773 LBB0_69
0x80, 0xc1, 0x30, //0x00000773 addb $48, %cl
0x88, 0x48, 0x02, //0x00000776 movb %cl, $2(%rax)
0x48, 0x83, 0xc0, 0x03, //0x00000779 addq $3, %rax
0xe9, 0xc1, 0x06, 0x00, 0x00, //0x0000077d jmp LBB0_155
//0x00000782 LBB0_141
0x4c, 0x89, 0xe6, //0x00000782 movq %r12, %rsi
0x4d, 0x89, 0xf9, //0x00000785 movq %r15, %r9
0x49, 0x83, 0xe1, 0xe0, //0x00000788 andq $-32, %r9
0x49, 0x8d, 0x41, 0xe0, //0x0000078c leaq $-32(%r9), %rax
0x48, 0x89, 0xc3, //0x00000790 movq %rax, %rbx
0x48, 0xc1, 0xeb, 0x05, //0x00000793 shrq $5, %rbx
0x48, 0x83, 0xc3, 0x01, //0x00000797 addq $1, %rbx
0x41, 0x89, 0xdc, //0x0000079b movl %ebx, %r12d
0x41, 0x83, 0xe4, 0x07, //0x0000079e andl $7, %r12d
0x48, 0x3d, 0xe0, 0x00, 0x00, 0x00, //0x000007a2 cmpq $224, %rax
0x0f, 0x83, 0x07, 0x00, 0x00, 0x00, //0x000007a8 jae LBB0_143
0x31, 0xc9, //0x000007ae xorl %ecx, %ecx
0xe9, 0xb0, 0x00, 0x00, 0x00, //0x000007b0 jmp LBB0_145
//0x000007b5 LBB0_143
0x4b, 0x8d, 0x04, 0x02, //0x000007b5 leaq (%r10,%r8), %rax
0x48, 0x8b, 0x4d, 0xd0, //0x000007b9 movq $-48(%rbp), %rcx
0x48, 0x01, 0xc8, //0x000007bd addq %rcx, %rax
0x48, 0x05, 0xf0, 0x00, 0x00, 0x00, //0x000007c0 addq $240, %rax
0x48, 0x83, 0xe3, 0xf8, //0x000007c6 andq $-8, %rbx
0x48, 0xf7, 0xdb, //0x000007ca negq %rbx
0x31, 0xc9, //0x000007cd xorl %ecx, %ecx
0xf3, 0x0f, 0x6f, 0x05, 0x29, 0xf8, 0xff, 0xff, //0x000007cf movdqu $-2007(%rip), %xmm0 /* LCPI0_0+0(%rip) */
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x000007d7 .p2align 4, 0x90
//0x000007e0 LBB0_144
0xf3, 0x0f, 0x7f, 0x84, 0x08, 0x10, 0xff, 0xff, 0xff, //0x000007e0 movdqu %xmm0, $-240(%rax,%rcx)
0xf3, 0x0f, 0x7f, 0x84, 0x08, 0x20, 0xff, 0xff, 0xff, //0x000007e9 movdqu %xmm0, $-224(%rax,%rcx)
0xf3, 0x0f, 0x7f, 0x84, 0x08, 0x30, 0xff, 0xff, 0xff, //0x000007f2 movdqu %xmm0, $-208(%rax,%rcx)
0xf3, 0x0f, 0x7f, 0x84, 0x08, 0x40, 0xff, 0xff, 0xff, //0x000007fb movdqu %xmm0, $-192(%rax,%rcx)
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | true |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/value_text_amd64.go | vendor/github.com/bytedance/sonic/internal/native/sse/value_text_amd64.go | // +build amd64
// Code generated by asm2asm, DO NOT EDIT.
package sse
var _text_value = []byte{
// .p2align 4, 0x00
// LCPI0_0
0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, // QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""'
//0x00000010 LCPI0_1
0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, //0x00000010 QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
//0x00000020 LCPI0_2
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, //0x00000020 QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' '
//0x00000030 LCPI0_3
0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, //0x00000030 QUAD $0x2f2f2f2f2f2f2f2f; QUAD $0x2f2f2f2f2f2f2f2f // .space 16, '////////////////'
//0x00000040 LCPI0_4
0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, //0x00000040 QUAD $0x3a3a3a3a3a3a3a3a; QUAD $0x3a3a3a3a3a3a3a3a // .space 16, '::::::::::::::::'
//0x00000050 LCPI0_5
0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, //0x00000050 QUAD $0x2b2b2b2b2b2b2b2b; QUAD $0x2b2b2b2b2b2b2b2b // .space 16, '++++++++++++++++'
//0x00000060 LCPI0_6
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, //0x00000060 QUAD $0x2d2d2d2d2d2d2d2d; QUAD $0x2d2d2d2d2d2d2d2d // .space 16, '----------------'
//0x00000070 LCPI0_7
0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, //0x00000070 QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf'
//0x00000080 LCPI0_8
0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, //0x00000080 QUAD $0x2e2e2e2e2e2e2e2e; QUAD $0x2e2e2e2e2e2e2e2e // .space 16, '................'
//0x00000090 LCPI0_9
0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, //0x00000090 QUAD $0x4545454545454545; QUAD $0x4545454545454545 // .space 16, 'EEEEEEEEEEEEEEEE'
//0x000000a0 LCPI0_10
0x00, 0x00, 0x30, 0x43, //0x000000a0 .long 1127219200
0x00, 0x00, 0x30, 0x45, //0x000000a4 .long 1160773632
0x00, 0x00, 0x00, 0x00, //0x000000a8 .long 0
0x00, 0x00, 0x00, 0x00, //0x000000ac .long 0
//0x000000b0 LCPI0_11
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x43, //0x000000b0 .quad 0x4330000000000000
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x45, //0x000000b8 .quad 0x4530000000000000
//0x000000c0 .p2align 3, 0x00
//0x000000c0 LCPI0_12
0x00, 0x00, 0x34, 0x26, 0xf5, 0x6b, 0x0c, 0x43, //0x000000c0 .quad 0x430c6bf526340000
//0x000000c8 LCPI0_13
0x00, 0x00, 0x34, 0x26, 0xf5, 0x6b, 0x0c, 0xc3, //0x000000c8 .quad 0xc30c6bf526340000
//0x000000d0 .p2align 4, 0x90
//0x000000d0 _value
0x55, //0x000000d0 pushq %rbp
0x48, 0x89, 0xe5, //0x000000d1 movq %rsp, %rbp
0x41, 0x57, //0x000000d4 pushq %r15
0x41, 0x56, //0x000000d6 pushq %r14
0x41, 0x55, //0x000000d8 pushq %r13
0x41, 0x54, //0x000000da pushq %r12
0x53, //0x000000dc pushq %rbx
0x48, 0x83, 0xec, 0x50, //0x000000dd subq $80, %rsp
0x4c, 0x89, 0xc0, //0x000000e1 movq %r8, %rax
0x49, 0x89, 0xc9, //0x000000e4 movq %rcx, %r9
0x48, 0x89, 0xd3, //0x000000e7 movq %rdx, %rbx
0x49, 0x89, 0xfe, //0x000000ea movq %rdi, %r14
0x48, 0x39, 0xf2, //0x000000ed cmpq %rsi, %rdx
0x0f, 0x83, 0x2a, 0x00, 0x00, 0x00, //0x000000f0 jae LBB0_5
0x41, 0x8a, 0x0c, 0x1e, //0x000000f6 movb (%r14,%rbx), %cl
0x80, 0xf9, 0x0d, //0x000000fa cmpb $13, %cl
0x0f, 0x84, 0x1d, 0x00, 0x00, 0x00, //0x000000fd je LBB0_5
0x80, 0xf9, 0x20, //0x00000103 cmpb $32, %cl
0x0f, 0x84, 0x14, 0x00, 0x00, 0x00, //0x00000106 je LBB0_5
0x8d, 0x51, 0xf7, //0x0000010c leal $-9(%rcx), %edx
0x80, 0xfa, 0x01, //0x0000010f cmpb $1, %dl
0x0f, 0x86, 0x08, 0x00, 0x00, 0x00, //0x00000112 jbe LBB0_5
0x49, 0x89, 0xd8, //0x00000118 movq %rbx, %r8
0xe9, 0x0b, 0x01, 0x00, 0x00, //0x0000011b jmp LBB0_28
//0x00000120 LBB0_5
0x4c, 0x8d, 0x43, 0x01, //0x00000120 leaq $1(%rbx), %r8
0x49, 0x39, 0xf0, //0x00000124 cmpq %rsi, %r8
0x0f, 0x83, 0x22, 0x00, 0x00, 0x00, //0x00000127 jae LBB0_9
0x43, 0x8a, 0x0c, 0x06, //0x0000012d movb (%r14,%r8), %cl
0x80, 0xf9, 0x0d, //0x00000131 cmpb $13, %cl
0x0f, 0x84, 0x15, 0x00, 0x00, 0x00, //0x00000134 je LBB0_9
0x80, 0xf9, 0x20, //0x0000013a cmpb $32, %cl
0x0f, 0x84, 0x0c, 0x00, 0x00, 0x00, //0x0000013d je LBB0_9
0x8d, 0x51, 0xf7, //0x00000143 leal $-9(%rcx), %edx
0x80, 0xfa, 0x01, //0x00000146 cmpb $1, %dl
0x0f, 0x87, 0xdc, 0x00, 0x00, 0x00, //0x00000149 ja LBB0_28
//0x0000014f LBB0_9
0x4c, 0x8d, 0x43, 0x02, //0x0000014f leaq $2(%rbx), %r8
0x49, 0x39, 0xf0, //0x00000153 cmpq %rsi, %r8
0x0f, 0x83, 0x22, 0x00, 0x00, 0x00, //0x00000156 jae LBB0_13
0x43, 0x8a, 0x0c, 0x06, //0x0000015c movb (%r14,%r8), %cl
0x80, 0xf9, 0x0d, //0x00000160 cmpb $13, %cl
0x0f, 0x84, 0x15, 0x00, 0x00, 0x00, //0x00000163 je LBB0_13
0x80, 0xf9, 0x20, //0x00000169 cmpb $32, %cl
0x0f, 0x84, 0x0c, 0x00, 0x00, 0x00, //0x0000016c je LBB0_13
0x8d, 0x51, 0xf7, //0x00000172 leal $-9(%rcx), %edx
0x80, 0xfa, 0x01, //0x00000175 cmpb $1, %dl
0x0f, 0x87, 0xad, 0x00, 0x00, 0x00, //0x00000178 ja LBB0_28
//0x0000017e LBB0_13
0x4c, 0x8d, 0x43, 0x03, //0x0000017e leaq $3(%rbx), %r8
0x49, 0x39, 0xf0, //0x00000182 cmpq %rsi, %r8
0x0f, 0x83, 0x22, 0x00, 0x00, 0x00, //0x00000185 jae LBB0_17
0x43, 0x8a, 0x0c, 0x06, //0x0000018b movb (%r14,%r8), %cl
0x80, 0xf9, 0x0d, //0x0000018f cmpb $13, %cl
0x0f, 0x84, 0x15, 0x00, 0x00, 0x00, //0x00000192 je LBB0_17
0x80, 0xf9, 0x20, //0x00000198 cmpb $32, %cl
0x0f, 0x84, 0x0c, 0x00, 0x00, 0x00, //0x0000019b je LBB0_17
0x8d, 0x51, 0xf7, //0x000001a1 leal $-9(%rcx), %edx
0x80, 0xfa, 0x01, //0x000001a4 cmpb $1, %dl
0x0f, 0x87, 0x7e, 0x00, 0x00, 0x00, //0x000001a7 ja LBB0_28
//0x000001ad LBB0_17
0x4c, 0x8d, 0x43, 0x04, //0x000001ad leaq $4(%rbx), %r8
0x49, 0x39, 0xf0, //0x000001b1 cmpq %rsi, %r8
0x0f, 0x83, 0x50, 0x00, 0x00, 0x00, //0x000001b4 jae LBB0_23
0x4c, 0x39, 0xc6, //0x000001ba cmpq %r8, %rsi
0x0f, 0x84, 0x4f, 0x00, 0x00, 0x00, //0x000001bd je LBB0_24
0x49, 0x8d, 0x0c, 0x36, //0x000001c3 leaq (%r14,%rsi), %rcx
0x48, 0xba, 0x00, 0x26, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, //0x000001c7 movabsq $4294977024, %rdx
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x000001d1 .p2align 4, 0x90
//0x000001e0 LBB0_20
0x43, 0x0f, 0xbe, 0x3c, 0x06, //0x000001e0 movsbl (%r14,%r8), %edi
0x83, 0xff, 0x20, //0x000001e5 cmpl $32, %edi
0x0f, 0x87, 0x30, 0x00, 0x00, 0x00, //0x000001e8 ja LBB0_26
0x48, 0x0f, 0xa3, 0xfa, //0x000001ee btq %rdi, %rdx
0x0f, 0x83, 0x26, 0x00, 0x00, 0x00, //0x000001f2 jae LBB0_26
0x49, 0x83, 0xc0, 0x01, //0x000001f8 addq $1, %r8
0x4c, 0x39, 0xc6, //0x000001fc cmpq %r8, %rsi
0x0f, 0x85, 0xdb, 0xff, 0xff, 0xff, //0x000001ff jne LBB0_20
0xe9, 0x0e, 0x00, 0x00, 0x00, //0x00000205 jmp LBB0_25
//0x0000020a LBB0_23
0x4c, 0x89, 0xc3, //0x0000020a movq %r8, %rbx
0xe9, 0xb7, 0x00, 0x00, 0x00, //0x0000020d jmp LBB0_37
//0x00000212 LBB0_24
0x4d, 0x01, 0xf0, //0x00000212 addq %r14, %r8
0x4c, 0x89, 0xc1, //0x00000215 movq %r8, %rcx
//0x00000218 LBB0_25
0x4c, 0x29, 0xf1, //0x00000218 subq %r14, %rcx
0x49, 0x89, 0xc8, //0x0000021b movq %rcx, %r8
//0x0000021e LBB0_26
0x49, 0x39, 0xf0, //0x0000021e cmpq %rsi, %r8
0x0f, 0x83, 0xa2, 0x00, 0x00, 0x00, //0x00000221 jae LBB0_37
0x43, 0x8a, 0x0c, 0x06, //0x00000227 movb (%r14,%r8), %cl
//0x0000022b LBB0_28
0x0f, 0xbe, 0xd1, //0x0000022b movsbl %cl, %edx
0x83, 0xfa, 0x7d, //0x0000022e cmpl $125, %edx
0x0f, 0x87, 0x99, 0x04, 0x00, 0x00, //0x00000231 ja LBB0_103
0x49, 0x8d, 0x58, 0x01, //0x00000237 leaq $1(%r8), %rbx
0x4f, 0x8d, 0x14, 0x06, //0x0000023b leaq (%r14,%r8), %r10
0x48, 0x8d, 0x3d, 0x96, 0x2c, 0x00, 0x00, //0x0000023f leaq $11414(%rip), %rdi /* LJTI0_0+0(%rip) */
0x48, 0x63, 0x14, 0x97, //0x00000246 movslq (%rdi,%rdx,4), %rdx
0x48, 0x01, 0xfa, //0x0000024a addq %rdi, %rdx
0xff, 0xe2, //0x0000024d jmpq *%rdx
//0x0000024f LBB0_30
0xa8, 0x02, //0x0000024f testb $2, %al
0x0f, 0x85, 0x8e, 0x00, 0x00, 0x00, //0x00000251 jne LBB0_40
0x4d, 0x8b, 0x69, 0x20, //0x00000257 movq $32(%r9), %r13
0x4d, 0x8b, 0x59, 0x28, //0x0000025b movq $40(%r9), %r11
0x49, 0xc7, 0x01, 0x09, 0x00, 0x00, 0x00, //0x0000025f movq $9, (%r9)
0x66, 0x0f, 0xef, 0xc0, //0x00000266 pxor %xmm0, %xmm0
0xf3, 0x41, 0x0f, 0x7f, 0x41, 0x08, //0x0000026a movdqu %xmm0, $8(%r9)
0x4d, 0x89, 0x41, 0x18, //0x00000270 movq %r8, $24(%r9)
0x49, 0x39, 0xf0, //0x00000274 cmpq %rsi, %r8
0x0f, 0x83, 0x3e, 0x0c, 0x00, 0x00, //0x00000277 jae LBB0_205
0x48, 0x89, 0xd8, //0x0000027d movq %rbx, %rax
0x45, 0x8a, 0x3a, //0x00000280 movb (%r10), %r15b
0x41, 0xbc, 0x01, 0x00, 0x00, 0x00, //0x00000283 movl $1, %r12d
0x44, 0x89, 0xfb, //0x00000289 movl %r15d, %ebx
0x4c, 0x89, 0xc1, //0x0000028c movq %r8, %rcx
0x41, 0x80, 0xff, 0x2d, //0x0000028f cmpb $45, %r15b
0x0f, 0x85, 0x16, 0x00, 0x00, 0x00, //0x00000293 jne LBB0_35
0x48, 0x39, 0xf0, //0x00000299 cmpq %rsi, %rax
0x0f, 0x83, 0x19, 0x0c, 0x00, 0x00, //0x0000029c jae LBB0_205
0x48, 0x89, 0xc1, //0x000002a2 movq %rax, %rcx
0x41, 0x8a, 0x1c, 0x06, //0x000002a5 movb (%r14,%rax), %bl
0x41, 0xbc, 0xff, 0xff, 0xff, 0xff, //0x000002a9 movl $-1, %r12d
//0x000002af LBB0_35
0x8d, 0x43, 0xd0, //0x000002af leal $-48(%rbx), %eax
0x3c, 0x0a, //0x000002b2 cmpb $10, %al
0x0f, 0x82, 0x37, 0x03, 0x00, 0x00, //0x000002b4 jb LBB0_88
0x49, 0xc7, 0x01, 0xfe, 0xff, 0xff, 0xff, //0x000002ba movq $-2, (%r9)
0x49, 0x89, 0xc9, //0x000002c1 movq %rcx, %r9
0xe9, 0x0a, 0x00, 0x00, 0x00, //0x000002c4 jmp LBB0_39
//0x000002c9 LBB0_37
0x49, 0xc7, 0x01, 0x01, 0x00, 0x00, 0x00, //0x000002c9 movq $1, (%r9)
//0x000002d0 LBB0_38
0x49, 0x89, 0xd9, //0x000002d0 movq %rbx, %r9
//0x000002d3 LBB0_39
0x4c, 0x89, 0xc8, //0x000002d3 movq %r9, %rax
0x48, 0x83, 0xc4, 0x50, //0x000002d6 addq $80, %rsp
0x5b, //0x000002da popq %rbx
0x41, 0x5c, //0x000002db popq %r12
0x41, 0x5d, //0x000002dd popq %r13
0x41, 0x5e, //0x000002df popq %r14
0x41, 0x5f, //0x000002e1 popq %r15
0x5d, //0x000002e3 popq %rbp
0xc3, //0x000002e4 retq
//0x000002e5 LBB0_40
0x4c, 0x89, 0x75, 0xa8, //0x000002e5 movq %r14, $-88(%rbp)
0x4c, 0x89, 0x4d, 0xa0, //0x000002e9 movq %r9, $-96(%rbp)
0x4c, 0x29, 0xc6, //0x000002ed subq %r8, %rsi
0x45, 0x31, 0xe4, //0x000002f0 xorl %r12d, %r12d
0x80, 0xf9, 0x2d, //0x000002f3 cmpb $45, %cl
0x41, 0x0f, 0x94, 0xc4, //0x000002f6 sete %r12b
0x4f, 0x8d, 0x0c, 0x22, //0x000002fa leaq (%r10,%r12), %r9
0x4c, 0x29, 0xe6, //0x000002fe subq %r12, %rsi
0x0f, 0x84, 0x48, 0x23, 0x00, 0x00, //0x00000301 je LBB0_543
0x41, 0x8a, 0x01, //0x00000307 movb (%r9), %al
0x8d, 0x48, 0xd0, //0x0000030a leal $-48(%rax), %ecx
0x80, 0xf9, 0x09, //0x0000030d cmpb $9, %cl
0x0f, 0x87, 0x83, 0x0d, 0x00, 0x00, //0x00000310 ja LBB0_236
0x3c, 0x30, //0x00000316 cmpb $48, %al
0x0f, 0x85, 0x34, 0x00, 0x00, 0x00, //0x00000318 jne LBB0_46
0xbb, 0x01, 0x00, 0x00, 0x00, //0x0000031e movl $1, %ebx
0x48, 0x83, 0xfe, 0x01, //0x00000323 cmpq $1, %rsi
0x0f, 0x84, 0x34, 0x0d, 0x00, 0x00, //0x00000327 je LBB0_233
0x41, 0x8a, 0x41, 0x01, //0x0000032d movb $1(%r9), %al
0x04, 0xd2, //0x00000331 addb $-46, %al
0x3c, 0x37, //0x00000333 cmpb $55, %al
0x0f, 0x87, 0x26, 0x0d, 0x00, 0x00, //0x00000335 ja LBB0_233
0x0f, 0xb6, 0xc0, //0x0000033b movzbl %al, %eax
0x48, 0xb9, 0x01, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, //0x0000033e movabsq $36028797027352577, %rcx
0x48, 0x0f, 0xa3, 0xc1, //0x00000348 btq %rax, %rcx
0x0f, 0x83, 0x0f, 0x0d, 0x00, 0x00, //0x0000034c jae LBB0_233
//0x00000352 LBB0_46
0x48, 0x83, 0xfe, 0x10, //0x00000352 cmpq $16, %rsi
0x4c, 0x89, 0x55, 0xc8, //0x00000356 movq %r10, $-56(%rbp)
0x0f, 0x82, 0x1a, 0x23, 0x00, 0x00, //0x0000035a jb LBB0_546
0x49, 0xc7, 0xc6, 0xff, 0xff, 0xff, 0xff, //0x00000360 movq $-1, %r14
0x31, 0xdb, //0x00000367 xorl %ebx, %ebx
0xf3, 0x44, 0x0f, 0x6f, 0x05, 0xbe, 0xfc, 0xff, 0xff, //0x00000369 movdqu $-834(%rip), %xmm8 /* LCPI0_3+0(%rip) */
0xf3, 0x44, 0x0f, 0x6f, 0x15, 0xc5, 0xfc, 0xff, 0xff, //0x00000372 movdqu $-827(%rip), %xmm10 /* LCPI0_4+0(%rip) */
0xf3, 0x44, 0x0f, 0x6f, 0x0d, 0xcc, 0xfc, 0xff, 0xff, //0x0000037b movdqu $-820(%rip), %xmm9 /* LCPI0_5+0(%rip) */
0xf3, 0x0f, 0x6f, 0x1d, 0xd4, 0xfc, 0xff, 0xff, //0x00000384 movdqu $-812(%rip), %xmm3 /* LCPI0_6+0(%rip) */
0xf3, 0x0f, 0x6f, 0x25, 0xdc, 0xfc, 0xff, 0xff, //0x0000038c movdqu $-804(%rip), %xmm4 /* LCPI0_7+0(%rip) */
0xf3, 0x0f, 0x6f, 0x2d, 0xe4, 0xfc, 0xff, 0xff, //0x00000394 movdqu $-796(%rip), %xmm5 /* LCPI0_8+0(%rip) */
0xf3, 0x0f, 0x6f, 0x35, 0xec, 0xfc, 0xff, 0xff, //0x0000039c movdqu $-788(%rip), %xmm6 /* LCPI0_9+0(%rip) */
0x49, 0xc7, 0xc5, 0xff, 0xff, 0xff, 0xff, //0x000003a4 movq $-1, %r13
0x49, 0xc7, 0xc7, 0xff, 0xff, 0xff, 0xff, //0x000003ab movq $-1, %r15
0x48, 0x89, 0xf2, //0x000003b2 movq %rsi, %rdx
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x000003b5 .p2align 4, 0x90
//0x000003c0 LBB0_48
0xf3, 0x41, 0x0f, 0x6f, 0x3c, 0x19, //0x000003c0 movdqu (%r9,%rbx), %xmm7
0x66, 0x0f, 0x6f, 0xc7, //0x000003c6 movdqa %xmm7, %xmm0
0x66, 0x41, 0x0f, 0x64, 0xc0, //0x000003ca pcmpgtb %xmm8, %xmm0
0x66, 0x41, 0x0f, 0x6f, 0xca, //0x000003cf movdqa %xmm10, %xmm1
0x66, 0x0f, 0x64, 0xcf, //0x000003d4 pcmpgtb %xmm7, %xmm1
0x66, 0x0f, 0xdb, 0xc8, //0x000003d8 pand %xmm0, %xmm1
0x66, 0x0f, 0x6f, 0xc7, //0x000003dc movdqa %xmm7, %xmm0
0x66, 0x41, 0x0f, 0x74, 0xc1, //0x000003e0 pcmpeqb %xmm9, %xmm0
0x66, 0x0f, 0x6f, 0xd7, //0x000003e5 movdqa %xmm7, %xmm2
0x66, 0x0f, 0x74, 0xd3, //0x000003e9 pcmpeqb %xmm3, %xmm2
0x66, 0x0f, 0xeb, 0xd0, //0x000003ed por %xmm0, %xmm2
0x66, 0x0f, 0x6f, 0xc7, //0x000003f1 movdqa %xmm7, %xmm0
0x66, 0x0f, 0xdb, 0xc4, //0x000003f5 pand %xmm4, %xmm0
0x66, 0x0f, 0x74, 0xc6, //0x000003f9 pcmpeqb %xmm6, %xmm0
0x66, 0x0f, 0x74, 0xfd, //0x000003fd pcmpeqb %xmm5, %xmm7
0x66, 0x44, 0x0f, 0xd7, 0xd8, //0x00000401 pmovmskb %xmm0, %r11d
0x66, 0x0f, 0xeb, 0xc7, //0x00000406 por %xmm7, %xmm0
0x66, 0x0f, 0xeb, 0xca, //0x0000040a por %xmm2, %xmm1
0x66, 0x0f, 0xeb, 0xc8, //0x0000040e por %xmm0, %xmm1
0x66, 0x0f, 0xd7, 0xc7, //0x00000412 pmovmskb %xmm7, %eax
0x66, 0x44, 0x0f, 0xd7, 0xd2, //0x00000416 pmovmskb %xmm2, %r10d
0x66, 0x0f, 0xd7, 0xc9, //0x0000041b pmovmskb %xmm1, %ecx
0xf7, 0xd1, //0x0000041f notl %ecx
0x0f, 0xbc, 0xc9, //0x00000421 bsfl %ecx, %ecx
0x83, 0xf9, 0x10, //0x00000424 cmpl $16, %ecx
0x0f, 0x84, 0x14, 0x00, 0x00, 0x00, //0x00000427 je LBB0_50
0xbf, 0xff, 0xff, 0xff, 0xff, //0x0000042d movl $-1, %edi
0xd3, 0xe7, //0x00000432 shll %cl, %edi
0xf7, 0xd7, //0x00000434 notl %edi
0x21, 0xf8, //0x00000436 andl %edi, %eax
0x41, 0x21, 0xfb, //0x00000438 andl %edi, %r11d
0x44, 0x21, 0xd7, //0x0000043b andl %r10d, %edi
0x41, 0x89, 0xfa, //0x0000043e movl %edi, %r10d
//0x00000441 LBB0_50
0x8d, 0x78, 0xff, //0x00000441 leal $-1(%rax), %edi
0x21, 0xc7, //0x00000444 andl %eax, %edi
0x0f, 0x85, 0xff, 0x08, 0x00, 0x00, //0x00000446 jne LBB0_175
0x41, 0x8d, 0x7b, 0xff, //0x0000044c leal $-1(%r11), %edi
0x44, 0x21, 0xdf, //0x00000450 andl %r11d, %edi
0x0f, 0x85, 0xf2, 0x08, 0x00, 0x00, //0x00000453 jne LBB0_175
0x41, 0x8d, 0x7a, 0xff, //0x00000459 leal $-1(%r10), %edi
0x44, 0x21, 0xd7, //0x0000045d andl %r10d, %edi
0x0f, 0x85, 0xe5, 0x08, 0x00, 0x00, //0x00000460 jne LBB0_175
0x85, 0xc0, //0x00000466 testl %eax, %eax
0x0f, 0x84, 0x13, 0x00, 0x00, 0x00, //0x00000468 je LBB0_56
0x0f, 0xbc, 0xc0, //0x0000046e bsfl %eax, %eax
0x49, 0x83, 0xff, 0xff, //0x00000471 cmpq $-1, %r15
0x0f, 0x85, 0xd5, 0x0b, 0x00, 0x00, //0x00000475 jne LBB0_230
0x48, 0x01, 0xd8, //0x0000047b addq %rbx, %rax
0x49, 0x89, 0xc7, //0x0000047e movq %rax, %r15
//0x00000481 LBB0_56
0x45, 0x85, 0xdb, //0x00000481 testl %r11d, %r11d
0x0f, 0x84, 0x14, 0x00, 0x00, 0x00, //0x00000484 je LBB0_59
0x41, 0x0f, 0xbc, 0xc3, //0x0000048a bsfl %r11d, %eax
0x49, 0x83, 0xfd, 0xff, //0x0000048e cmpq $-1, %r13
0x0f, 0x85, 0xb8, 0x0b, 0x00, 0x00, //0x00000492 jne LBB0_230
0x48, 0x01, 0xd8, //0x00000498 addq %rbx, %rax
0x49, 0x89, 0xc5, //0x0000049b movq %rax, %r13
//0x0000049e LBB0_59
0x45, 0x85, 0xd2, //0x0000049e testl %r10d, %r10d
0x0f, 0x84, 0x14, 0x00, 0x00, 0x00, //0x000004a1 je LBB0_62
0x41, 0x0f, 0xbc, 0xc2, //0x000004a7 bsfl %r10d, %eax
0x49, 0x83, 0xfe, 0xff, //0x000004ab cmpq $-1, %r14
0x0f, 0x85, 0x9b, 0x0b, 0x00, 0x00, //0x000004af jne LBB0_230
0x48, 0x01, 0xd8, //0x000004b5 addq %rbx, %rax
0x49, 0x89, 0xc6, //0x000004b8 movq %rax, %r14
//0x000004bb LBB0_62
0x83, 0xf9, 0x10, //0x000004bb cmpl $16, %ecx
0x0f, 0x85, 0xb4, 0x00, 0x00, 0x00, //0x000004be jne LBB0_77
0x48, 0x83, 0xc2, 0xf0, //0x000004c4 addq $-16, %rdx
0x48, 0x83, 0xc3, 0x10, //0x000004c8 addq $16, %rbx
0x48, 0x83, 0xfa, 0x0f, //0x000004cc cmpq $15, %rdx
0x0f, 0x87, 0xea, 0xfe, 0xff, 0xff, //0x000004d0 ja LBB0_48
0x49, 0x8d, 0x0c, 0x19, //0x000004d6 leaq (%r9,%rbx), %rcx
0x49, 0x89, 0xca, //0x000004da movq %rcx, %r10
0x48, 0x39, 0xde, //0x000004dd cmpq %rbx, %rsi
0x0f, 0x84, 0xa6, 0x00, 0x00, 0x00, //0x000004e0 je LBB0_79
//0x000004e6 LBB0_65
0x4c, 0x8d, 0x14, 0x11, //0x000004e6 leaq (%rcx,%rdx), %r10
0x48, 0x89, 0xc8, //0x000004ea movq %rcx, %rax
0x4c, 0x29, 0xc8, //0x000004ed subq %r9, %rax
0x31, 0xdb, //0x000004f0 xorl %ebx, %ebx
0x4c, 0x8d, 0x1d, 0xdb, 0x2b, 0x00, 0x00, //0x000004f2 leaq $11227(%rip), %r11 /* LJTI0_1+0(%rip) */
0xe9, 0x2f, 0x00, 0x00, 0x00, //0x000004f9 jmp LBB0_70
//0x000004fe LBB0_66
0x83, 0xff, 0x65, //0x000004fe cmpl $101, %edi
0x0f, 0x85, 0x7f, 0x00, 0x00, 0x00, //0x00000501 jne LBB0_78
//0x00000507 LBB0_67
0x49, 0x83, 0xfd, 0xff, //0x00000507 cmpq $-1, %r13
0x0f, 0x85, 0xc4, 0x09, 0x00, 0x00, //0x0000050b jne LBB0_207
0x4c, 0x8d, 0x2c, 0x18, //0x00000511 leaq (%rax,%rbx), %r13
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000515 .p2align 4, 0x90
//0x00000520 LBB0_69
0x48, 0x83, 0xc3, 0x01, //0x00000520 addq $1, %rbx
0x48, 0x39, 0xda, //0x00000524 cmpq %rbx, %rdx
0x0f, 0x84, 0x5f, 0x00, 0x00, 0x00, //0x00000527 je LBB0_79
//0x0000052d LBB0_70
0x0f, 0xbe, 0x3c, 0x19, //0x0000052d movsbl (%rcx,%rbx), %edi
0x8d, 0x77, 0xd0, //0x00000531 leal $-48(%rdi), %esi
0x83, 0xfe, 0x0a, //0x00000534 cmpl $10, %esi
0x0f, 0x82, 0xe3, 0xff, 0xff, 0xff, //0x00000537 jb LBB0_69
0x8d, 0x77, 0xd5, //0x0000053d leal $-43(%rdi), %esi
0x83, 0xfe, 0x1a, //0x00000540 cmpl $26, %esi
0x0f, 0x87, 0xb5, 0xff, 0xff, 0xff, //0x00000543 ja LBB0_66
0x49, 0x63, 0x34, 0xb3, //0x00000549 movslq (%r11,%rsi,4), %rsi
0x4c, 0x01, 0xde, //0x0000054d addq %r11, %rsi
0xff, 0xe6, //0x00000550 jmpq *%rsi
//0x00000552 LBB0_73
0x49, 0x83, 0xfe, 0xff, //0x00000552 cmpq $-1, %r14
0x0f, 0x85, 0x79, 0x09, 0x00, 0x00, //0x00000556 jne LBB0_207
0x4c, 0x8d, 0x34, 0x18, //0x0000055c leaq (%rax,%rbx), %r14
0xe9, 0xbb, 0xff, 0xff, 0xff, //0x00000560 jmp LBB0_69
//0x00000565 LBB0_75
0x49, 0x83, 0xff, 0xff, //0x00000565 cmpq $-1, %r15
0x0f, 0x85, 0x66, 0x09, 0x00, 0x00, //0x00000569 jne LBB0_207
0x4c, 0x8d, 0x3c, 0x18, //0x0000056f leaq (%rax,%rbx), %r15
0xe9, 0xa8, 0xff, 0xff, 0xff, //0x00000573 jmp LBB0_69
//0x00000578 LBB0_77
0x41, 0x89, 0xca, //0x00000578 movl %ecx, %r10d
0x4d, 0x01, 0xca, //0x0000057b addq %r9, %r10
0x49, 0x01, 0xda, //0x0000057e addq %rbx, %r10
0xe9, 0x06, 0x00, 0x00, 0x00, //0x00000581 jmp LBB0_79
//0x00000586 LBB0_78
0x48, 0x01, 0xd9, //0x00000586 addq %rbx, %rcx
0x49, 0x89, 0xca, //0x00000589 movq %rcx, %r10
//0x0000058c LBB0_79
0x48, 0xc7, 0xc3, 0xff, 0xff, 0xff, 0xff, //0x0000058c movq $-1, %rbx
0x4d, 0x85, 0xff, //0x00000593 testq %r15, %r15
0x0f, 0x84, 0xf7, 0x0a, 0x00, 0x00, //0x00000596 je LBB0_235
0x4d, 0x85, 0xf6, //0x0000059c testq %r14, %r14
0x0f, 0x84, 0xee, 0x0a, 0x00, 0x00, //0x0000059f je LBB0_235
0x4d, 0x85, 0xed, //0x000005a5 testq %r13, %r13
0x0f, 0x84, 0xe5, 0x0a, 0x00, 0x00, //0x000005a8 je LBB0_235
0x4d, 0x29, 0xca, //0x000005ae subq %r9, %r10
0x49, 0x8d, 0x42, 0xff, //0x000005b1 leaq $-1(%r10), %rax
0x49, 0x39, 0xc7, //0x000005b5 cmpq %rax, %r15
0x0f, 0x84, 0xd4, 0x03, 0x00, 0x00, //0x000005b8 je LBB0_133
0x49, 0x39, 0xc6, //0x000005be cmpq %rax, %r14
0x0f, 0x84, 0xcb, 0x03, 0x00, 0x00, //0x000005c1 je LBB0_133
0x49, 0x39, 0xc5, //0x000005c7 cmpq %rax, %r13
0x0f, 0x84, 0xc2, 0x03, 0x00, 0x00, //0x000005ca je LBB0_133
0x4d, 0x85, 0xf6, //0x000005d0 testq %r14, %r14
0x0f, 0x8e, 0x08, 0x06, 0x00, 0x00, //0x000005d3 jle LBB0_149
0x49, 0x8d, 0x46, 0xff, //0x000005d9 leaq $-1(%r14), %rax
0x49, 0x39, 0xc5, //0x000005dd cmpq %rax, %r13
0x0f, 0x84, 0xfb, 0x05, 0x00, 0x00, //0x000005e0 je LBB0_149
0x49, 0xf7, 0xd6, //0x000005e6 notq %r14
0x4c, 0x89, 0xf3, //0x000005e9 movq %r14, %rbx
0xe9, 0x67, 0x0a, 0x00, 0x00, //0x000005ec jmp LBB0_232
//0x000005f1 LBB0_88
0x4c, 0x89, 0x4d, 0xa0, //0x000005f1 movq %r9, $-96(%rbp)
0x80, 0xfb, 0x30, //0x000005f5 cmpb $48, %bl
0x0f, 0x85, 0x32, 0x00, 0x00, 0x00, //0x000005f8 jne LBB0_92
0x4c, 0x8d, 0x49, 0x01, //0x000005fe leaq $1(%rcx), %r9
0x48, 0x39, 0xf1, //0x00000602 cmpq %rsi, %rcx
0x0f, 0x83, 0xc8, 0xfc, 0xff, 0xff, //0x00000605 jae LBB0_39
0x43, 0x8a, 0x04, 0x0e, //0x0000060b movb (%r14,%r9), %al
0x04, 0xd2, //0x0000060f addb $-46, %al
0x3c, 0x37, //0x00000611 cmpb $55, %al
0x0f, 0x87, 0xba, 0xfc, 0xff, 0xff, //0x00000613 ja LBB0_39
0x0f, 0xb6, 0xc0, //0x00000619 movzbl %al, %eax
0x48, 0xba, 0x01, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, //0x0000061c movabsq $36028797027352577, %rdx
0x48, 0x0f, 0xa3, 0xc2, //0x00000626 btq %rax, %rdx
0x0f, 0x83, 0xa3, 0xfc, 0xff, 0xff, //0x0000062a jae LBB0_39
//0x00000630 LBB0_92
0x4c, 0x89, 0x55, 0xc8, //0x00000630 movq %r10, $-56(%rbp)
0xb0, 0x01, //0x00000634 movb $1, %al
0x89, 0x45, 0xb8, //0x00000636 movl %eax, $-72(%rbp)
0x48, 0x39, 0xf1, //0x00000639 cmpq %rsi, %rcx
0x0f, 0x83, 0xc2, 0x05, 0x00, 0x00, //0x0000063c jae LBB0_152
0x41, 0xb9, 0xd0, 0xff, 0xff, 0xff, //0x00000642 movl $4294967248, %r9d
0x48, 0x83, 0xc1, 0x01, //0x00000648 addq $1, %rcx
0x31, 0xd2, //0x0000064c xorl %edx, %edx
0x31, 0xc0, //0x0000064e xorl %eax, %eax
0x45, 0x31, 0xd2, //0x00000650 xorl %r10d, %r10d
//0x00000653 LBB0_94
0x83, 0xf8, 0x12, //0x00000653 cmpl $18, %eax
0x0f, 0x8f, 0x16, 0x00, 0x00, 0x00, //0x00000656 jg LBB0_96
0x4b, 0x8d, 0x3c, 0x92, //0x0000065c leaq (%r10,%r10,4), %rdi
0x0f, 0xb6, 0xdb, //0x00000660 movzbl %bl, %ebx
0x44, 0x01, 0xcb, //0x00000663 addl %r9d, %ebx
0x4c, 0x8d, 0x14, 0x7b, //0x00000666 leaq (%rbx,%rdi,2), %r10
0x83, 0xc0, 0x01, //0x0000066a addl $1, %eax
0xe9, 0x03, 0x00, 0x00, 0x00, //0x0000066d jmp LBB0_97
//0x00000672 LBB0_96
0x83, 0xc2, 0x01, //0x00000672 addl $1, %edx
//0x00000675 LBB0_97
0x48, 0x39, 0xce, //0x00000675 cmpq %rcx, %rsi
0x0f, 0x84, 0xab, 0x06, 0x00, 0x00, //0x00000678 je LBB0_172
0x41, 0x0f, 0xb6, 0x1c, 0x0e, //0x0000067e movzbl (%r14,%rcx), %ebx
0x8d, 0x7b, 0xd0, //0x00000683 leal $-48(%rbx), %edi
0x48, 0x83, 0xc1, 0x01, //0x00000686 addq $1, %rcx
0x40, 0x80, 0xff, 0x0a, //0x0000068a cmpb $10, %dil
0x0f, 0x82, 0xbf, 0xff, 0xff, 0xff, //0x0000068e jb LBB0_94
0x80, 0xfb, 0x2e, //0x00000694 cmpb $46, %bl
0x0f, 0x85, 0xb6, 0x06, 0x00, 0x00, //0x00000697 jne LBB0_176
0x48, 0x8b, 0x7d, 0xa0, //0x0000069d movq $-96(%rbp), %rdi
0x48, 0xc7, 0x07, 0x08, 0x00, 0x00, 0x00, //0x000006a1 movq $8, (%rdi)
0x48, 0x39, 0xf1, //0x000006a8 cmpq %rsi, %rcx
0x0f, 0x83, 0x40, 0x0a, 0x00, 0x00, //0x000006ab jae LBB0_240
0x41, 0x8a, 0x1c, 0x0e, //0x000006b1 movb (%r14,%rcx), %bl
0x80, 0xc3, 0xd0, //0x000006b5 addb $-48, %bl
0x80, 0xfb, 0x0a, //0x000006b8 cmpb $10, %bl
0x0f, 0x82, 0xfb, 0x0d, 0x00, 0x00, //0x000006bb jb LBB0_286
0x48, 0xc7, 0x07, 0xfe, 0xff, 0xff, 0xff, //0x000006c1 movq $-2, (%rdi)
0x49, 0x89, 0xc9, //0x000006c8 movq %rcx, %r9
0xe9, 0x03, 0xfc, 0xff, 0xff, //0x000006cb jmp LBB0_39
//0x000006d0 LBB0_103
0x49, 0xc7, 0x01, 0xfe, 0xff, 0xff, 0xff, //0x000006d0 movq $-2, (%r9)
0x4d, 0x89, 0xc1, //0x000006d7 movq %r8, %r9
0xe9, 0xf4, 0xfb, 0xff, 0xff, //0x000006da jmp LBB0_39
//0x000006df LBB0_104
0xa8, 0x20, //0x000006df testb $32, %al
0x4c, 0x89, 0x4d, 0xa0, //0x000006e1 movq %r9, $-96(%rbp)
0x48, 0x89, 0x5d, 0xb8, //0x000006e5 movq %rbx, $-72(%rbp)
0x0f, 0x85, 0xae, 0x02, 0x00, 0x00, //0x000006e9 jne LBB0_134
0x48, 0x39, 0xf3, //0x000006ef cmpq %rsi, %rbx
0x0f, 0x84, 0xd5, 0x27, 0x00, 0x00, //0x000006f2 je LBB0_620
0x49, 0x89, 0xf4, //0x000006f8 movq %rsi, %r12
0x49, 0x29, 0xdc, //0x000006fb subq %rbx, %r12
0x49, 0x83, 0xfc, 0x40, //0x000006fe cmpq $64, %r12
0x0f, 0x82, 0x69, 0x24, 0x00, 0x00, //0x00000702 jb LBB0_621
0x49, 0xc7, 0xc3, 0xfe, 0xff, 0xff, 0xff, //0x00000708 movq $-2, %r11
0x4d, 0x29, 0xc3, //0x0000070f subq %r8, %r11
0x49, 0x83, 0xc0, 0x01, //0x00000712 addq $1, %r8
0x48, 0xc7, 0x45, 0xc0, 0xff, 0xff, 0xff, 0xff, //0x00000716 movq $-1, $-64(%rbp)
0x45, 0x31, 0xff, //0x0000071e xorl %r15d, %r15d
0xf3, 0x0f, 0x6f, 0x05, 0xd7, 0xf8, 0xff, 0xff, //0x00000721 movdqu $-1833(%rip), %xmm0 /* LCPI0_0+0(%rip) */
0xf3, 0x0f, 0x6f, 0x0d, 0xdf, 0xf8, 0xff, 0xff, //0x00000729 movdqu $-1825(%rip), %xmm1 /* LCPI0_1+0(%rip) */
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000731 .p2align 4, 0x90
//0x00000740 LBB0_108
0x4c, 0x89, 0xf0, //0x00000740 movq %r14, %rax
0xf3, 0x43, 0x0f, 0x6f, 0x14, 0x06, //0x00000743 movdqu (%r14,%r8), %xmm2
0xf3, 0x43, 0x0f, 0x6f, 0x5c, 0x06, 0x10, //0x00000749 movdqu $16(%r14,%r8), %xmm3
0xf3, 0x43, 0x0f, 0x6f, 0x64, 0x06, 0x20, //0x00000750 movdqu $32(%r14,%r8), %xmm4
0xf3, 0x43, 0x0f, 0x6f, 0x6c, 0x06, 0x30, //0x00000757 movdqu $48(%r14,%r8), %xmm5
0x66, 0x0f, 0x6f, 0xf2, //0x0000075e movdqa %xmm2, %xmm6
0x66, 0x0f, 0x74, 0xf0, //0x00000762 pcmpeqb %xmm0, %xmm6
0x66, 0x44, 0x0f, 0xd7, 0xd6, //0x00000766 pmovmskb %xmm6, %r10d
0x66, 0x0f, 0x6f, 0xf3, //0x0000076b movdqa %xmm3, %xmm6
0x66, 0x0f, 0x74, 0xf0, //0x0000076f pcmpeqb %xmm0, %xmm6
0x66, 0x0f, 0xd7, 0xfe, //0x00000773 pmovmskb %xmm6, %edi
0x66, 0x0f, 0x6f, 0xf4, //0x00000777 movdqa %xmm4, %xmm6
0x66, 0x0f, 0x74, 0xf0, //0x0000077b pcmpeqb %xmm0, %xmm6
0x66, 0x0f, 0xd7, 0xce, //0x0000077f pmovmskb %xmm6, %ecx
0x66, 0x0f, 0x6f, 0xf5, //0x00000783 movdqa %xmm5, %xmm6
0x66, 0x0f, 0x74, 0xf0, //0x00000787 pcmpeqb %xmm0, %xmm6
0x66, 0x0f, 0xd7, 0xc6, //0x0000078b pmovmskb %xmm6, %eax
0x66, 0x0f, 0x74, 0xd1, //0x0000078f pcmpeqb %xmm1, %xmm2
0x66, 0x44, 0x0f, 0xd7, 0xea, //0x00000793 pmovmskb %xmm2, %r13d
0x66, 0x0f, 0x74, 0xd9, //0x00000798 pcmpeqb %xmm1, %xmm3
0x66, 0x0f, 0xd7, 0xd3, //0x0000079c pmovmskb %xmm3, %edx
0x66, 0x0f, 0x74, 0xe1, //0x000007a0 pcmpeqb %xmm1, %xmm4
0x66, 0x0f, 0xd7, 0xdc, //0x000007a4 pmovmskb %xmm4, %ebx
0x66, 0x0f, 0x74, 0xe9, //0x000007a8 pcmpeqb %xmm1, %xmm5
0x66, 0x44, 0x0f, 0xd7, 0xcd, //0x000007ac pmovmskb %xmm5, %r9d
0x48, 0xc1, 0xe0, 0x30, //0x000007b1 shlq $48, %rax
0x48, 0xc1, 0xe1, 0x20, //0x000007b5 shlq $32, %rcx
0x48, 0x09, 0xc1, //0x000007b9 orq %rax, %rcx
0x48, 0xc1, 0xe7, 0x10, //0x000007bc shlq $16, %rdi
0x48, 0x09, 0xcf, //0x000007c0 orq %rcx, %rdi
0x49, 0x09, 0xfa, //0x000007c3 orq %rdi, %r10
0x49, 0xc1, 0xe1, 0x30, //0x000007c6 shlq $48, %r9
0x48, 0xc1, 0xe3, 0x20, //0x000007ca shlq $32, %rbx
0x4c, 0x09, 0xcb, //0x000007ce orq %r9, %rbx
0x48, 0xc1, 0xe2, 0x10, //0x000007d1 shlq $16, %rdx
0x48, 0x09, 0xda, //0x000007d5 orq %rbx, %rdx
0x49, 0x09, 0xd5, //0x000007d8 orq %rdx, %r13
0x0f, 0x85, 0x30, 0x00, 0x00, 0x00, //0x000007db jne LBB0_112
0x4d, 0x85, 0xff, //0x000007e1 testq %r15, %r15
0x0f, 0x85, 0x3d, 0x00, 0x00, 0x00, //0x000007e4 jne LBB0_114
0x45, 0x31, 0xff, //0x000007ea xorl %r15d, %r15d
0x4d, 0x85, 0xd2, //0x000007ed testq %r10, %r10
0x0f, 0x85, 0x83, 0x00, 0x00, 0x00, //0x000007f0 jne LBB0_115
//0x000007f6 LBB0_111
0x49, 0x83, 0xc4, 0xc0, //0x000007f6 addq $-64, %r12
0x49, 0x83, 0xc3, 0xc0, //0x000007fa addq $-64, %r11
0x49, 0x83, 0xc0, 0x40, //0x000007fe addq $64, %r8
0x49, 0x83, 0xfc, 0x3f, //0x00000802 cmpq $63, %r12
0x0f, 0x87, 0x34, 0xff, 0xff, 0xff, //0x00000806 ja LBB0_108
0xe9, 0x89, 0x0d, 0x00, 0x00, //0x0000080c jmp LBB0_298
//0x00000811 LBB0_112
0x48, 0x83, 0x7d, 0xc0, 0xff, //0x00000811 cmpq $-1, $-64(%rbp)
0x0f, 0x85, 0x0b, 0x00, 0x00, 0x00, //0x00000816 jne LBB0_114
0x49, 0x0f, 0xbc, 0xc5, //0x0000081c bsfq %r13, %rax
0x4c, 0x01, 0xc0, //0x00000820 addq %r8, %rax
0x48, 0x89, 0x45, 0xc0, //0x00000823 movq %rax, $-64(%rbp)
//0x00000827 LBB0_114
0x4c, 0x89, 0xf8, //0x00000827 movq %r15, %rax
0x48, 0xf7, 0xd0, //0x0000082a notq %rax
0x4c, 0x21, 0xe8, //0x0000082d andq %r13, %rax
0x48, 0x8d, 0x0c, 0x00, //0x00000830 leaq (%rax,%rax), %rcx
0x4c, 0x09, 0xf9, //0x00000834 orq %r15, %rcx
0x48, 0x89, 0xca, //0x00000837 movq %rcx, %rdx
0x48, 0xf7, 0xd2, //0x0000083a notq %rdx
0x4c, 0x21, 0xea, //0x0000083d andq %r13, %rdx
0x48, 0xbf, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, //0x00000840 movabsq $-6148914691236517206, %rdi
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | true |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/skip_one_fast.go | vendor/github.com/bytedance/sonic/internal/native/sse/skip_one_fast.go | // 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
import (
`unsafe`
`github.com/bytedance/sonic/internal/rt`
)
var F_skip_one_fast func(s unsafe.Pointer, p unsafe.Pointer) (ret int)
var S_skip_one_fast uintptr
//go:nosplit
func skip_one_fast(s *string, p *int) (ret int) {
return F_skip_one_fast(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)))
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/i64toa.go | vendor/github.com/bytedance/sonic/internal/native/sse/i64toa.go | // 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
import (
`unsafe`
`github.com/bytedance/sonic/internal/rt`
)
var F_i64toa func(out unsafe.Pointer, val int64) (ret int)
var S_i64toa uintptr
//go:nosplit
func i64toa(out *byte, val int64) (ret int) {
return F_i64toa(rt.NoEscape(unsafe.Pointer(out)), val)
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/get_by_path_text_amd64.go | vendor/github.com/bytedance/sonic/internal/native/sse/get_by_path_text_amd64.go | // +build amd64
// Code generated by asm2asm, DO NOT EDIT.
package sse
var _text_get_by_path = []byte{
// .p2align 4, 0x00
// LCPI0_0
0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, // QUAD $0x2c2c2c2c2c2c2c2c; QUAD $0x2c2c2c2c2c2c2c2c // .space 16, ',,,,,,,,,,,,,,,,'
//0x00000010 LCPI0_1
0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, //0x00000010 QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf'
//0x00000020 LCPI0_2
0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, //0x00000020 QUAD $0x5d5d5d5d5d5d5d5d; QUAD $0x5d5d5d5d5d5d5d5d // .space 16, ']]]]]]]]]]]]]]]]'
//0x00000030 LCPI0_3
0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, //0x00000030 QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""'
//0x00000040 LCPI0_4
0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, //0x00000040 QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
//0x00000050 LCPI0_5
0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, //0x00000050 QUAD $0x7b7b7b7b7b7b7b7b; QUAD $0x7b7b7b7b7b7b7b7b // .space 16, '{{{{{{{{{{{{{{{{'
//0x00000060 LCPI0_6
0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, //0x00000060 QUAD $0x7d7d7d7d7d7d7d7d; QUAD $0x7d7d7d7d7d7d7d7d // .space 16, '}}}}}}}}}}}}}}}}'
//0x00000070 LCPI0_7
0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, //0x00000070 QUAD $0x5b5b5b5b5b5b5b5b; QUAD $0x5b5b5b5b5b5b5b5b // .space 16, '[[[[[[[[[[[[[[[['
//0x00000080 LCPI0_8
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000080 .quad 1
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000088 .quad 0
//0x00000090 LCPI0_9
0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, //0x00000090 QUAD $0x2f2f2f2f2f2f2f2f; QUAD $0x2f2f2f2f2f2f2f2f // .space 16, '////////////////'
//0x000000a0 LCPI0_10
0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, //0x000000a0 QUAD $0x3a3a3a3a3a3a3a3a; QUAD $0x3a3a3a3a3a3a3a3a // .space 16, '::::::::::::::::'
//0x000000b0 LCPI0_11
0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, //0x000000b0 QUAD $0x2b2b2b2b2b2b2b2b; QUAD $0x2b2b2b2b2b2b2b2b // .space 16, '++++++++++++++++'
//0x000000c0 LCPI0_12
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, //0x000000c0 QUAD $0x2d2d2d2d2d2d2d2d; QUAD $0x2d2d2d2d2d2d2d2d // .space 16, '----------------'
//0x000000d0 LCPI0_13
0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, //0x000000d0 QUAD $0x2e2e2e2e2e2e2e2e; QUAD $0x2e2e2e2e2e2e2e2e // .space 16, '................'
//0x000000e0 LCPI0_14
0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, //0x000000e0 QUAD $0x4545454545454545; QUAD $0x4545454545454545 // .space 16, 'EEEEEEEEEEEEEEEE'
//0x000000f0 .p2align 4, 0x90
//0x000000f0 _get_by_path
0x55, //0x000000f0 pushq %rbp
0x48, 0x89, 0xe5, //0x000000f1 movq %rsp, %rbp
0x41, 0x57, //0x000000f4 pushq %r15
0x41, 0x56, //0x000000f6 pushq %r14
0x41, 0x55, //0x000000f8 pushq %r13
0x41, 0x54, //0x000000fa pushq %r12
0x53, //0x000000fc pushq %rbx
0x48, 0x81, 0xec, 0xa8, 0x00, 0x00, 0x00, //0x000000fd subq $168, %rsp
0x49, 0x89, 0xc9, //0x00000104 movq %rcx, %r9
0x49, 0x89, 0xf0, //0x00000107 movq %rsi, %r8
0x49, 0x89, 0xfc, //0x0000010a movq %rdi, %r12
0x48, 0x8b, 0x42, 0x08, //0x0000010d movq $8(%rdx), %rax
0x4c, 0x8d, 0x7f, 0x08, //0x00000111 leaq $8(%rdi), %r15
0x48, 0x85, 0xc0, //0x00000115 testq %rax, %rax
0x48, 0x89, 0x75, 0xc8, //0x00000118 movq %rsi, $-56(%rbp)
0x4c, 0x89, 0x7d, 0xc0, //0x0000011c movq %r15, $-64(%rbp)
0x48, 0x89, 0x4d, 0x98, //0x00000120 movq %rcx, $-104(%rbp)
0x0f, 0x84, 0xce, 0x2c, 0x00, 0x00, //0x00000124 je LBB0_459
0x4c, 0x8b, 0x1a, //0x0000012a movq (%rdx), %r11
0x48, 0xc1, 0xe0, 0x04, //0x0000012d shlq $4, %rax
0x4c, 0x01, 0xd8, //0x00000131 addq %r11, %rax
0x48, 0x89, 0x85, 0x38, 0xff, 0xff, 0xff, //0x00000134 movq %rax, $-200(%rbp)
0x4d, 0x8b, 0x2c, 0x24, //0x0000013b movq (%r12), %r13
0x49, 0x8b, 0x00, //0x0000013f movq (%r8), %rax
0xf3, 0x0f, 0x6f, 0x05, 0xe6, 0xfe, 0xff, 0xff, //0x00000142 movdqu $-282(%rip), %xmm0 /* LCPI0_3+0(%rip) */
0xf3, 0x0f, 0x6f, 0x0d, 0xee, 0xfe, 0xff, 0xff, //0x0000014a movdqu $-274(%rip), %xmm1 /* LCPI0_4+0(%rip) */
0xf3, 0x44, 0x0f, 0x6f, 0x2d, 0xa5, 0xfe, 0xff, 0xff, //0x00000152 movdqu $-347(%rip), %xmm13 /* LCPI0_0+0(%rip) */
0xf3, 0x44, 0x0f, 0x6f, 0x35, 0xac, 0xfe, 0xff, 0xff, //0x0000015b movdqu $-340(%rip), %xmm14 /* LCPI0_1+0(%rip) */
0xf3, 0x0f, 0x6f, 0x25, 0xb4, 0xfe, 0xff, 0xff, //0x00000164 movdqu $-332(%rip), %xmm4 /* LCPI0_2+0(%rip) */
0x66, 0x45, 0x0f, 0x76, 0xc9, //0x0000016c pcmpeqd %xmm9, %xmm9
0xf3, 0x44, 0x0f, 0x6f, 0x15, 0xf6, 0xfe, 0xff, 0xff, //0x00000171 movdqu $-266(%rip), %xmm10 /* LCPI0_7+0(%rip) */
0x66, 0x45, 0x0f, 0xef, 0xc0, //0x0000017a pxor %xmm8, %xmm8
0xf3, 0x44, 0x0f, 0x6f, 0x1d, 0xc8, 0xfe, 0xff, 0xff, //0x0000017f movdqu $-312(%rip), %xmm11 /* LCPI0_5+0(%rip) */
0xf3, 0x44, 0x0f, 0x6f, 0x25, 0xcf, 0xfe, 0xff, 0xff, //0x00000188 movdqu $-305(%rip), %xmm12 /* LCPI0_6+0(%rip) */
0x4c, 0x89, 0x65, 0xb0, //0x00000191 movq %r12, $-80(%rbp)
//0x00000195 LBB0_2
0x49, 0x8b, 0x0f, //0x00000195 movq (%r15), %rcx
0x48, 0x39, 0xc8, //0x00000198 cmpq %rcx, %rax
0x0f, 0x83, 0x2f, 0x00, 0x00, 0x00, //0x0000019b jae LBB0_7
0x41, 0x8a, 0x54, 0x05, 0x00, //0x000001a1 movb (%r13,%rax), %dl
0x80, 0xfa, 0x0d, //0x000001a6 cmpb $13, %dl
0x0f, 0x84, 0x21, 0x00, 0x00, 0x00, //0x000001a9 je LBB0_7
0x80, 0xfa, 0x20, //0x000001af cmpb $32, %dl
0x0f, 0x84, 0x18, 0x00, 0x00, 0x00, //0x000001b2 je LBB0_7
0x80, 0xc2, 0xf7, //0x000001b8 addb $-9, %dl
0x80, 0xfa, 0x01, //0x000001bb cmpb $1, %dl
0x0f, 0x86, 0x0c, 0x00, 0x00, 0x00, //0x000001be jbe LBB0_7
0x48, 0x89, 0xc2, //0x000001c4 movq %rax, %rdx
0xe9, 0x2c, 0x01, 0x00, 0x00, //0x000001c7 jmp LBB0_28
0x90, 0x90, 0x90, 0x90, //0x000001cc .p2align 4, 0x90
//0x000001d0 LBB0_7
0x48, 0x8d, 0x50, 0x01, //0x000001d0 leaq $1(%rax), %rdx
0x48, 0x39, 0xca, //0x000001d4 cmpq %rcx, %rdx
0x0f, 0x83, 0x23, 0x00, 0x00, 0x00, //0x000001d7 jae LBB0_11
0x41, 0x8a, 0x5c, 0x15, 0x00, //0x000001dd movb (%r13,%rdx), %bl
0x80, 0xfb, 0x0d, //0x000001e2 cmpb $13, %bl
0x0f, 0x84, 0x15, 0x00, 0x00, 0x00, //0x000001e5 je LBB0_11
0x80, 0xfb, 0x20, //0x000001eb cmpb $32, %bl
0x0f, 0x84, 0x0c, 0x00, 0x00, 0x00, //0x000001ee je LBB0_11
0x80, 0xc3, 0xf7, //0x000001f4 addb $-9, %bl
0x80, 0xfb, 0x01, //0x000001f7 cmpb $1, %bl
0x0f, 0x87, 0xf8, 0x00, 0x00, 0x00, //0x000001fa ja LBB0_28
//0x00000200 .p2align 4, 0x90
//0x00000200 LBB0_11
0x48, 0x8d, 0x50, 0x02, //0x00000200 leaq $2(%rax), %rdx
0x48, 0x39, 0xca, //0x00000204 cmpq %rcx, %rdx
0x0f, 0x83, 0x23, 0x00, 0x00, 0x00, //0x00000207 jae LBB0_15
0x41, 0x8a, 0x5c, 0x15, 0x00, //0x0000020d movb (%r13,%rdx), %bl
0x80, 0xfb, 0x0d, //0x00000212 cmpb $13, %bl
0x0f, 0x84, 0x15, 0x00, 0x00, 0x00, //0x00000215 je LBB0_15
0x80, 0xfb, 0x20, //0x0000021b cmpb $32, %bl
0x0f, 0x84, 0x0c, 0x00, 0x00, 0x00, //0x0000021e je LBB0_15
0x80, 0xc3, 0xf7, //0x00000224 addb $-9, %bl
0x80, 0xfb, 0x01, //0x00000227 cmpb $1, %bl
0x0f, 0x87, 0xc8, 0x00, 0x00, 0x00, //0x0000022a ja LBB0_28
//0x00000230 .p2align 4, 0x90
//0x00000230 LBB0_15
0x48, 0x8d, 0x50, 0x03, //0x00000230 leaq $3(%rax), %rdx
0x48, 0x39, 0xca, //0x00000234 cmpq %rcx, %rdx
0x0f, 0x83, 0x23, 0x00, 0x00, 0x00, //0x00000237 jae LBB0_19
0x41, 0x8a, 0x5c, 0x15, 0x00, //0x0000023d movb (%r13,%rdx), %bl
0x80, 0xfb, 0x0d, //0x00000242 cmpb $13, %bl
0x0f, 0x84, 0x15, 0x00, 0x00, 0x00, //0x00000245 je LBB0_19
0x80, 0xfb, 0x20, //0x0000024b cmpb $32, %bl
0x0f, 0x84, 0x0c, 0x00, 0x00, 0x00, //0x0000024e je LBB0_19
0x80, 0xc3, 0xf7, //0x00000254 addb $-9, %bl
0x80, 0xfb, 0x01, //0x00000257 cmpb $1, %bl
0x0f, 0x87, 0x98, 0x00, 0x00, 0x00, //0x0000025a ja LBB0_28
//0x00000260 .p2align 4, 0x90
//0x00000260 LBB0_19
0x4c, 0x8d, 0x50, 0x04, //0x00000260 leaq $4(%rax), %r10
0x4c, 0x39, 0xd1, //0x00000264 cmpq %r10, %rcx
0x0f, 0x86, 0x53, 0x00, 0x00, 0x00, //0x00000267 jbe LBB0_860
0x4c, 0x39, 0xd1, //0x0000026d cmpq %r10, %rcx
0x0f, 0x84, 0x6a, 0x00, 0x00, 0x00, //0x00000270 je LBB0_25
0x4a, 0x8d, 0x14, 0x29, //0x00000276 leaq (%rcx,%r13), %rdx
0x48, 0xbf, 0x00, 0x26, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, //0x0000027a movabsq $4294977024, %rdi
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000284 .p2align 4, 0x90
//0x00000290 LBB0_22
0x43, 0x0f, 0xbe, 0x74, 0x15, 0x00, //0x00000290 movsbl (%r13,%r10), %esi
0x83, 0xfe, 0x20, //0x00000296 cmpl $32, %esi
0x0f, 0x87, 0x4d, 0x00, 0x00, 0x00, //0x00000299 ja LBB0_27
0x48, 0x0f, 0xa3, 0xf7, //0x0000029f btq %rsi, %rdi
0x0f, 0x83, 0x43, 0x00, 0x00, 0x00, //0x000002a3 jae LBB0_27
0x49, 0x83, 0xc2, 0x01, //0x000002a9 addq $1, %r10
0x4c, 0x39, 0xd1, //0x000002ad cmpq %r10, %rcx
0x0f, 0x85, 0xda, 0xff, 0xff, 0xff, //0x000002b0 jne LBB0_22
0xe9, 0x2b, 0x00, 0x00, 0x00, //0x000002b6 jmp LBB0_26
0x90, 0x90, 0x90, 0x90, 0x90, //0x000002bb .p2align 4, 0x90
//0x000002c0 LBB0_860
0x4d, 0x89, 0x10, //0x000002c0 movq %r10, (%r8)
0x31, 0xc9, //0x000002c3 xorl %ecx, %ecx
0x49, 0x8b, 0x03, //0x000002c5 movq (%r11), %rax
0x48, 0x85, 0xc0, //0x000002c8 testq %rax, %rax
0x49, 0xb9, 0x00, 0x26, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, //0x000002cb movabsq $4294977024, %r9
0x0f, 0x85, 0x65, 0x00, 0x00, 0x00, //0x000002d5 jne LBB0_30
0xe9, 0x23, 0x43, 0x00, 0x00, //0x000002db jmp LBB0_861
//0x000002e0 LBB0_25
0x4d, 0x01, 0xea, //0x000002e0 addq %r13, %r10
0x4c, 0x89, 0xd2, //0x000002e3 movq %r10, %rdx
//0x000002e6 LBB0_26
0x4c, 0x29, 0xea, //0x000002e6 subq %r13, %rdx
0x49, 0x89, 0xd2, //0x000002e9 movq %rdx, %r10
//0x000002ec LBB0_27
0x4c, 0x89, 0xd2, //0x000002ec movq %r10, %rdx
0x49, 0x39, 0xca, //0x000002ef cmpq %rcx, %r10
0x0f, 0x83, 0x27, 0x00, 0x00, 0x00, //0x000002f2 jae LBB0_29
//0x000002f8 LBB0_28
0x4c, 0x8d, 0x52, 0x01, //0x000002f8 leaq $1(%rdx), %r10
0x4d, 0x89, 0x10, //0x000002fc movq %r10, (%r8)
0x41, 0x8a, 0x4c, 0x15, 0x00, //0x000002ff movb (%r13,%rdx), %cl
0x49, 0x8b, 0x03, //0x00000304 movq (%r11), %rax
0x48, 0x85, 0xc0, //0x00000307 testq %rax, %rax
0x49, 0xb9, 0x00, 0x26, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, //0x0000030a movabsq $4294977024, %r9
0x0f, 0x85, 0x26, 0x00, 0x00, 0x00, //0x00000314 jne LBB0_30
0xe9, 0xe4, 0x42, 0x00, 0x00, //0x0000031a jmp LBB0_861
//0x0000031f LBB0_29
0x31, 0xc9, //0x0000031f xorl %ecx, %ecx
0x49, 0x89, 0xc2, //0x00000321 movq %rax, %r10
0x49, 0x8b, 0x03, //0x00000324 movq (%r11), %rax
0x48, 0x85, 0xc0, //0x00000327 testq %rax, %rax
0x49, 0xb9, 0x00, 0x26, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, //0x0000032a movabsq $4294977024, %r9
0x0f, 0x84, 0xc9, 0x42, 0x00, 0x00, //0x00000334 je LBB0_861
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x0000033a .p2align 4, 0x90
//0x00000340 LBB0_30
0x8a, 0x40, 0x17, //0x00000340 movb $23(%rax), %al
0x24, 0x1f, //0x00000343 andb $31, %al
0x3c, 0x02, //0x00000345 cmpb $2, %al
0x0f, 0x84, 0x93, 0x1a, 0x00, 0x00, //0x00000347 je LBB0_342
0x3c, 0x18, //0x0000034d cmpb $24, %al
0x0f, 0x85, 0xae, 0x42, 0x00, 0x00, //0x0000034f jne LBB0_861
0x80, 0xf9, 0x7b, //0x00000355 cmpb $123, %cl
0x4c, 0x89, 0x5d, 0xa8, //0x00000358 movq %r11, $-88(%rbp)
0x0f, 0x85, 0xe1, 0x42, 0x00, 0x00, //0x0000035c jne LBB0_868
//0x00000362 LBB0_33
0x49, 0x8b, 0x0f, //0x00000362 movq (%r15), %rcx
0x49, 0x39, 0xca, //0x00000365 cmpq %rcx, %r10
0x0f, 0x83, 0x32, 0x00, 0x00, 0x00, //0x00000368 jae LBB0_38
0x43, 0x8a, 0x44, 0x15, 0x00, //0x0000036e movb (%r13,%r10), %al
0x3c, 0x0d, //0x00000373 cmpb $13, %al
0x0f, 0x84, 0x25, 0x00, 0x00, 0x00, //0x00000375 je LBB0_38
0x3c, 0x20, //0x0000037b cmpb $32, %al
0x0f, 0x84, 0x1d, 0x00, 0x00, 0x00, //0x0000037d je LBB0_38
0x04, 0xf7, //0x00000383 addb $-9, %al
0x3c, 0x01, //0x00000385 cmpb $1, %al
0x0f, 0x86, 0x13, 0x00, 0x00, 0x00, //0x00000387 jbe LBB0_38
0x4c, 0x89, 0xd0, //0x0000038d movq %r10, %rax
0xe9, 0x00, 0x01, 0x00, 0x00, //0x00000390 jmp LBB0_59
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000395 .p2align 4, 0x90
//0x000003a0 LBB0_38
0x49, 0x8d, 0x42, 0x01, //0x000003a0 leaq $1(%r10), %rax
0x48, 0x39, 0xc8, //0x000003a4 cmpq %rcx, %rax
0x0f, 0x83, 0x23, 0x00, 0x00, 0x00, //0x000003a7 jae LBB0_42
0x41, 0x8a, 0x54, 0x05, 0x00, //0x000003ad movb (%r13,%rax), %dl
0x80, 0xfa, 0x0d, //0x000003b2 cmpb $13, %dl
0x0f, 0x84, 0x15, 0x00, 0x00, 0x00, //0x000003b5 je LBB0_42
0x80, 0xfa, 0x20, //0x000003bb cmpb $32, %dl
0x0f, 0x84, 0x0c, 0x00, 0x00, 0x00, //0x000003be je LBB0_42
0x80, 0xc2, 0xf7, //0x000003c4 addb $-9, %dl
0x80, 0xfa, 0x01, //0x000003c7 cmpb $1, %dl
0x0f, 0x87, 0xc5, 0x00, 0x00, 0x00, //0x000003ca ja LBB0_59
//0x000003d0 .p2align 4, 0x90
//0x000003d0 LBB0_42
0x49, 0x8d, 0x42, 0x02, //0x000003d0 leaq $2(%r10), %rax
0x48, 0x39, 0xc8, //0x000003d4 cmpq %rcx, %rax
0x0f, 0x83, 0x23, 0x00, 0x00, 0x00, //0x000003d7 jae LBB0_46
0x41, 0x8a, 0x54, 0x05, 0x00, //0x000003dd movb (%r13,%rax), %dl
0x80, 0xfa, 0x0d, //0x000003e2 cmpb $13, %dl
0x0f, 0x84, 0x15, 0x00, 0x00, 0x00, //0x000003e5 je LBB0_46
0x80, 0xfa, 0x20, //0x000003eb cmpb $32, %dl
0x0f, 0x84, 0x0c, 0x00, 0x00, 0x00, //0x000003ee je LBB0_46
0x80, 0xc2, 0xf7, //0x000003f4 addb $-9, %dl
0x80, 0xfa, 0x01, //0x000003f7 cmpb $1, %dl
0x0f, 0x87, 0x95, 0x00, 0x00, 0x00, //0x000003fa ja LBB0_59
//0x00000400 .p2align 4, 0x90
//0x00000400 LBB0_46
0x49, 0x8d, 0x42, 0x03, //0x00000400 leaq $3(%r10), %rax
0x48, 0x39, 0xc8, //0x00000404 cmpq %rcx, %rax
0x0f, 0x83, 0x23, 0x00, 0x00, 0x00, //0x00000407 jae LBB0_50
0x41, 0x8a, 0x54, 0x05, 0x00, //0x0000040d movb (%r13,%rax), %dl
0x80, 0xfa, 0x0d, //0x00000412 cmpb $13, %dl
0x0f, 0x84, 0x15, 0x00, 0x00, 0x00, //0x00000415 je LBB0_50
0x80, 0xfa, 0x20, //0x0000041b cmpb $32, %dl
0x0f, 0x84, 0x0c, 0x00, 0x00, 0x00, //0x0000041e je LBB0_50
0x80, 0xc2, 0xf7, //0x00000424 addb $-9, %dl
0x80, 0xfa, 0x01, //0x00000427 cmpb $1, %dl
0x0f, 0x87, 0x65, 0x00, 0x00, 0x00, //0x0000042a ja LBB0_59
//0x00000430 .p2align 4, 0x90
//0x00000430 LBB0_50
0x49, 0x8d, 0x42, 0x04, //0x00000430 leaq $4(%r10), %rax
0x48, 0x39, 0xc1, //0x00000434 cmpq %rax, %rcx
0x0f, 0x86, 0xfb, 0x41, 0x00, 0x00, //0x00000437 jbe LBB0_865
0x48, 0x39, 0xc1, //0x0000043d cmpq %rax, %rcx
0x0f, 0x84, 0x3a, 0x00, 0x00, 0x00, //0x00000440 je LBB0_56
0x4a, 0x8d, 0x14, 0x29, //0x00000446 leaq (%rcx,%r13), %rdx
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x0000044a .p2align 4, 0x90
//0x00000450 LBB0_53
0x41, 0x0f, 0xbe, 0x74, 0x05, 0x00, //0x00000450 movsbl (%r13,%rax), %esi
0x83, 0xfe, 0x20, //0x00000456 cmpl $32, %esi
0x0f, 0x87, 0x2d, 0x00, 0x00, 0x00, //0x00000459 ja LBB0_58
0x49, 0x0f, 0xa3, 0xf1, //0x0000045f btq %rsi, %r9
0x0f, 0x83, 0x23, 0x00, 0x00, 0x00, //0x00000463 jae LBB0_58
0x48, 0x83, 0xc0, 0x01, //0x00000469 addq $1, %rax
0x48, 0x39, 0xc1, //0x0000046d cmpq %rax, %rcx
0x0f, 0x85, 0xda, 0xff, 0xff, 0xff, //0x00000470 jne LBB0_53
0xe9, 0x0b, 0x00, 0x00, 0x00, //0x00000476 jmp LBB0_57
0x90, 0x90, 0x90, 0x90, 0x90, //0x0000047b .p2align 4, 0x90
//0x00000480 LBB0_56
0x4c, 0x01, 0xe8, //0x00000480 addq %r13, %rax
0x48, 0x89, 0xc2, //0x00000483 movq %rax, %rdx
//0x00000486 LBB0_57
0x4c, 0x29, 0xea, //0x00000486 subq %r13, %rdx
0x48, 0x89, 0xd0, //0x00000489 movq %rdx, %rax
//0x0000048c LBB0_58
0x48, 0x39, 0xc8, //0x0000048c cmpq %rcx, %rax
0x0f, 0x83, 0xae, 0x41, 0x00, 0x00, //0x0000048f jae LBB0_868
//0x00000495 LBB0_59
0x4c, 0x8d, 0x50, 0x01, //0x00000495 leaq $1(%rax), %r10
0x4d, 0x89, 0x10, //0x00000499 movq %r10, (%r8)
0x41, 0x8a, 0x54, 0x05, 0x00, //0x0000049c movb (%r13,%rax), %dl
0x80, 0xfa, 0x22, //0x000004a1 cmpb $34, %dl
0x0f, 0x85, 0x2d, 0x2b, 0x00, 0x00, //0x000004a4 jne LBB0_550
0x49, 0x8b, 0x0f, //0x000004aa movq (%r15), %rcx
0x49, 0x89, 0xc8, //0x000004ad movq %rcx, %r8
0x4d, 0x29, 0xd0, //0x000004b0 subq %r10, %r8
0x0f, 0x84, 0xe8, 0x4d, 0x00, 0x00, //0x000004b3 je LBB0_966
0x48, 0x89, 0x8d, 0x48, 0xff, 0xff, 0xff, //0x000004b9 movq %rcx, $-184(%rbp)
0x49, 0x8b, 0x73, 0x08, //0x000004c0 movq $8(%r11), %rsi
0x4c, 0x8b, 0x36, //0x000004c4 movq (%rsi), %r14
0x48, 0x8b, 0x4e, 0x08, //0x000004c7 movq $8(%rsi), %rcx
0x48, 0x89, 0x4d, 0xd0, //0x000004cb movq %rcx, $-48(%rbp)
0x4c, 0x89, 0x95, 0x40, 0xff, 0xff, 0xff, //0x000004cf movq %r10, $-192(%rbp)
0x4b, 0x8d, 0x1c, 0x2a, //0x000004d6 leaq (%r10,%r13), %rbx
0x49, 0x83, 0xf8, 0x40, //0x000004da cmpq $64, %r8
0x48, 0x89, 0x5d, 0x90, //0x000004de movq %rbx, $-112(%rbp)
0x0f, 0x82, 0xa5, 0x12, 0x00, 0x00, //0x000004e2 jb LBB0_266
0x4c, 0x89, 0x75, 0xa0, //0x000004e8 movq %r14, $-96(%rbp)
0x49, 0xc7, 0xc6, 0xfe, 0xff, 0xff, 0xff, //0x000004ec movq $-2, %r14
0x49, 0x29, 0xc6, //0x000004f3 subq %rax, %r14
0x4c, 0x8d, 0x50, 0x01, //0x000004f6 leaq $1(%rax), %r10
0x48, 0xc7, 0x45, 0xb8, 0xff, 0xff, 0xff, 0xff, //0x000004fa movq $-1, $-72(%rbp)
0x45, 0x31, 0xc9, //0x00000502 xorl %r9d, %r9d
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000505 .p2align 4, 0x90
//0x00000510 LBB0_63
0xf3, 0x43, 0x0f, 0x6f, 0x5c, 0x15, 0x00, //0x00000510 movdqu (%r13,%r10), %xmm3
0xf3, 0x43, 0x0f, 0x6f, 0x6c, 0x15, 0x10, //0x00000517 movdqu $16(%r13,%r10), %xmm5
0xf3, 0x43, 0x0f, 0x6f, 0x74, 0x15, 0x20, //0x0000051e movdqu $32(%r13,%r10), %xmm6
0xf3, 0x43, 0x0f, 0x6f, 0x7c, 0x15, 0x30, //0x00000525 movdqu $48(%r13,%r10), %xmm7
0x66, 0x0f, 0x6f, 0xd3, //0x0000052c movdqa %xmm3, %xmm2
0x66, 0x0f, 0x74, 0xd0, //0x00000530 pcmpeqb %xmm0, %xmm2
0x66, 0x0f, 0xd7, 0xfa, //0x00000534 pmovmskb %xmm2, %edi
0x66, 0x0f, 0x6f, 0xd5, //0x00000538 movdqa %xmm5, %xmm2
0x66, 0x0f, 0x74, 0xd0, //0x0000053c pcmpeqb %xmm0, %xmm2
0x66, 0x44, 0x0f, 0xd7, 0xfa, //0x00000540 pmovmskb %xmm2, %r15d
0x66, 0x0f, 0x6f, 0xd6, //0x00000545 movdqa %xmm6, %xmm2
0x66, 0x0f, 0x74, 0xd0, //0x00000549 pcmpeqb %xmm0, %xmm2
0x66, 0x44, 0x0f, 0xd7, 0xe2, //0x0000054d pmovmskb %xmm2, %r12d
0x66, 0x0f, 0x6f, 0xd7, //0x00000552 movdqa %xmm7, %xmm2
0x66, 0x0f, 0x74, 0xd0, //0x00000556 pcmpeqb %xmm0, %xmm2
0x66, 0x44, 0x0f, 0xd7, 0xda, //0x0000055a pmovmskb %xmm2, %r11d
0x66, 0x0f, 0x74, 0xd9, //0x0000055f pcmpeqb %xmm1, %xmm3
0x66, 0x0f, 0xd7, 0xf3, //0x00000563 pmovmskb %xmm3, %esi
0x66, 0x0f, 0x74, 0xe9, //0x00000567 pcmpeqb %xmm1, %xmm5
0x66, 0x0f, 0xd7, 0xdd, //0x0000056b pmovmskb %xmm5, %ebx
0x66, 0x0f, 0x74, 0xf1, //0x0000056f pcmpeqb %xmm1, %xmm6
0x66, 0x0f, 0xd7, 0xd6, //0x00000573 pmovmskb %xmm6, %edx
0x66, 0x0f, 0x74, 0xf9, //0x00000577 pcmpeqb %xmm1, %xmm7
0x66, 0x0f, 0xd7, 0xcf, //0x0000057b pmovmskb %xmm7, %ecx
0x49, 0xc1, 0xe3, 0x30, //0x0000057f shlq $48, %r11
0x49, 0xc1, 0xe4, 0x20, //0x00000583 shlq $32, %r12
0x4d, 0x09, 0xdc, //0x00000587 orq %r11, %r12
0x49, 0xc1, 0xe7, 0x10, //0x0000058a shlq $16, %r15
0x4d, 0x09, 0xe7, //0x0000058e orq %r12, %r15
0x4c, 0x09, 0xff, //0x00000591 orq %r15, %rdi
0x48, 0xc1, 0xe1, 0x30, //0x00000594 shlq $48, %rcx
0x48, 0xc1, 0xe2, 0x20, //0x00000598 shlq $32, %rdx
0x48, 0x09, 0xca, //0x0000059c orq %rcx, %rdx
0x48, 0xc1, 0xe3, 0x10, //0x0000059f shlq $16, %rbx
0x48, 0x09, 0xd3, //0x000005a3 orq %rdx, %rbx
0x48, 0x09, 0xde, //0x000005a6 orq %rbx, %rsi
0x0f, 0x85, 0x30, 0x00, 0x00, 0x00, //0x000005a9 jne LBB0_72
0x4d, 0x85, 0xc9, //0x000005af testq %r9, %r9
0x0f, 0x85, 0x3d, 0x00, 0x00, 0x00, //0x000005b2 jne LBB0_74
0x45, 0x31, 0xc9, //0x000005b8 xorl %r9d, %r9d
0x48, 0x85, 0xff, //0x000005bb testq %rdi, %rdi
0x0f, 0x85, 0x8c, 0x00, 0x00, 0x00, //0x000005be jne LBB0_75
//0x000005c4 LBB0_66
0x49, 0x83, 0xc0, 0xc0, //0x000005c4 addq $-64, %r8
0x49, 0x83, 0xc6, 0xc0, //0x000005c8 addq $-64, %r14
0x49, 0x83, 0xc2, 0x40, //0x000005cc addq $64, %r10
0x49, 0x83, 0xf8, 0x3f, //0x000005d0 cmpq $63, %r8
0x0f, 0x87, 0x36, 0xff, 0xff, 0xff, //0x000005d4 ja LBB0_63
0xe9, 0xae, 0x10, 0x00, 0x00, //0x000005da jmp LBB0_67
//0x000005df LBB0_72
0x48, 0x83, 0x7d, 0xb8, 0xff, //0x000005df cmpq $-1, $-72(%rbp)
0x0f, 0x85, 0x0b, 0x00, 0x00, 0x00, //0x000005e4 jne LBB0_74
0x48, 0x0f, 0xbc, 0xce, //0x000005ea bsfq %rsi, %rcx
0x4c, 0x01, 0xd1, //0x000005ee addq %r10, %rcx
0x48, 0x89, 0x4d, 0xb8, //0x000005f1 movq %rcx, $-72(%rbp)
//0x000005f5 LBB0_74
0x4c, 0x89, 0xc9, //0x000005f5 movq %r9, %rcx
0x48, 0xf7, 0xd1, //0x000005f8 notq %rcx
0x48, 0x21, 0xf1, //0x000005fb andq %rsi, %rcx
0x48, 0x8d, 0x1c, 0x09, //0x000005fe leaq (%rcx,%rcx), %rbx
0x4c, 0x09, 0xcb, //0x00000602 orq %r9, %rbx
0x48, 0x89, 0xda, //0x00000605 movq %rbx, %rdx
0x48, 0xf7, 0xd2, //0x00000608 notq %rdx
0x48, 0x21, 0xf2, //0x0000060b andq %rsi, %rdx
0x48, 0xbe, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, //0x0000060e movabsq $-6148914691236517206, %rsi
0x48, 0x21, 0xf2, //0x00000618 andq %rsi, %rdx
0x45, 0x31, 0xc9, //0x0000061b xorl %r9d, %r9d
0x48, 0x01, 0xca, //0x0000061e addq %rcx, %rdx
0x41, 0x0f, 0x92, 0xc1, //0x00000621 setb %r9b
0x48, 0x01, 0xd2, //0x00000625 addq %rdx, %rdx
0x48, 0xb9, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, //0x00000628 movabsq $6148914691236517205, %rcx
0x48, 0x31, 0xca, //0x00000632 xorq %rcx, %rdx
0x48, 0x21, 0xda, //0x00000635 andq %rbx, %rdx
0x48, 0xf7, 0xd2, //0x00000638 notq %rdx
0x48, 0x21, 0xd7, //0x0000063b andq %rdx, %rdi
0x48, 0x85, 0xff, //0x0000063e testq %rdi, %rdi
0x0f, 0x84, 0x7d, 0xff, 0xff, 0xff, //0x00000641 je LBB0_66
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000647 .p2align 4, 0x90
//0x00000650 LBB0_75
0x4c, 0x0f, 0xbc, 0xd7, //0x00000650 bsfq %rdi, %r10
0x4d, 0x29, 0xf2, //0x00000654 subq %r14, %r10
0x4c, 0x8b, 0x45, 0xc8, //0x00000657 movq $-56(%rbp), %r8
0x4c, 0x8b, 0x7d, 0xc0, //0x0000065b movq $-64(%rbp), %r15
0x4c, 0x8b, 0x65, 0xb0, //0x0000065f movq $-80(%rbp), %r12
0x4c, 0x8b, 0x5d, 0xa8, //0x00000663 movq $-88(%rbp), %r11
0x49, 0xb9, 0x00, 0x26, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, //0x00000667 movabsq $4294977024, %r9
0x4c, 0x8b, 0x75, 0xa0, //0x00000671 movq $-96(%rbp), %r14
0x48, 0x8b, 0x5d, 0x90, //0x00000675 movq $-112(%rbp), %rbx
0x48, 0x8b, 0x4d, 0xb8, //0x00000679 movq $-72(%rbp), %rcx
0x4d, 0x85, 0xd2, //0x0000067d testq %r10, %r10
0x0f, 0x88, 0x26, 0x4c, 0x00, 0x00, //0x00000680 js LBB0_968
//0x00000686 LBB0_78
0x4d, 0x89, 0x10, //0x00000686 movq %r10, (%r8)
0x48, 0x83, 0xf9, 0xff, //0x00000689 cmpq $-1, %rcx
0x0f, 0x84, 0x09, 0x00, 0x00, 0x00, //0x0000068d je LBB0_80
0x4c, 0x39, 0xd1, //0x00000693 cmpq %r10, %rcx
0x0f, 0x8e, 0x0e, 0x11, 0x00, 0x00, //0x00000696 jle LBB0_267
//0x0000069c LBB0_80
0x4c, 0x89, 0xd2, //0x0000069c movq %r10, %rdx
0x48, 0x29, 0xc2, //0x0000069f subq %rax, %rdx
0x48, 0x83, 0xc2, 0xfe, //0x000006a2 addq $-2, %rdx
0xb9, 0x01, 0x00, 0x00, 0x00, //0x000006a6 movl $1, %ecx
0x48, 0x89, 0xd6, //0x000006ab movq %rdx, %rsi
0x48, 0x8b, 0x7d, 0xd0, //0x000006ae movq $-48(%rbp), %rdi
0x48, 0x09, 0xfe, //0x000006b2 orq %rdi, %rsi
0x0f, 0x84, 0x46, 0x00, 0x00, 0x00, //0x000006b5 je LBB0_86
0x48, 0x39, 0xfa, //0x000006bb cmpq %rdi, %rdx
0x0f, 0x85, 0x3b, 0x00, 0x00, 0x00, //0x000006be jne LBB0_85
0x31, 0xf6, //0x000006c4 xorl %esi, %esi
0x48, 0x89, 0xfa, //0x000006c6 movq %rdi, %rdx
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x000006c9 .p2align 4, 0x90
//0x000006d0 LBB0_83
0x48, 0x83, 0xfa, 0x10, //0x000006d0 cmpq $16, %rdx
0x0f, 0x82, 0xa1, 0x02, 0x00, 0x00, //0x000006d4 jb LBB0_138
0xf3, 0x0f, 0x6f, 0x14, 0x33, //0x000006da movdqu (%rbx,%rsi), %xmm2
0xf3, 0x41, 0x0f, 0x6f, 0x1c, 0x36, //0x000006df movdqu (%r14,%rsi), %xmm3
0x66, 0x0f, 0x74, 0xda, //0x000006e5 pcmpeqb %xmm2, %xmm3
0x66, 0x0f, 0xd7, 0xfb, //0x000006e9 pmovmskb %xmm3, %edi
0x48, 0x83, 0xc2, 0xf0, //0x000006ed addq $-16, %rdx
0x48, 0x83, 0xc6, 0x10, //0x000006f1 addq $16, %rsi
0x66, 0x83, 0xff, 0xff, //0x000006f5 cmpw $-1, %di
0x0f, 0x84, 0xd1, 0xff, 0xff, 0xff, //0x000006f9 je LBB0_83
//0x000006ff LBB0_85
0x31, 0xc9, //0x000006ff xorl %ecx, %ecx
//0x00000701 LBB0_86
0x49, 0x8b, 0x07, //0x00000701 movq (%r15), %rax
0x49, 0x39, 0xc2, //0x00000704 cmpq %rax, %r10
0x0f, 0x83, 0x33, 0x00, 0x00, 0x00, //0x00000707 jae LBB0_91
0x43, 0x8a, 0x54, 0x15, 0x00, //0x0000070d movb (%r13,%r10), %dl
0x80, 0xfa, 0x0d, //0x00000712 cmpb $13, %dl
0x0f, 0x84, 0x25, 0x00, 0x00, 0x00, //0x00000715 je LBB0_91
0x80, 0xfa, 0x20, //0x0000071b cmpb $32, %dl
0x0f, 0x84, 0x1c, 0x00, 0x00, 0x00, //0x0000071e je LBB0_91
0x80, 0xc2, 0xf7, //0x00000724 addb $-9, %dl
0x80, 0xfa, 0x01, //0x00000727 cmpb $1, %dl
0x0f, 0x86, 0x10, 0x00, 0x00, 0x00, //0x0000072a jbe LBB0_91
0x4c, 0x89, 0xd2, //0x00000730 movq %r10, %rdx
0xe9, 0xfd, 0x00, 0x00, 0x00, //0x00000733 jmp LBB0_112
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000738 .p2align 4, 0x90
//0x00000740 LBB0_91
0x49, 0x8d, 0x52, 0x01, //0x00000740 leaq $1(%r10), %rdx
0x48, 0x39, 0xc2, //0x00000744 cmpq %rax, %rdx
0x0f, 0x83, 0x23, 0x00, 0x00, 0x00, //0x00000747 jae LBB0_95
0x41, 0x8a, 0x5c, 0x15, 0x00, //0x0000074d movb (%r13,%rdx), %bl
0x80, 0xfb, 0x0d, //0x00000752 cmpb $13, %bl
0x0f, 0x84, 0x15, 0x00, 0x00, 0x00, //0x00000755 je LBB0_95
0x80, 0xfb, 0x20, //0x0000075b cmpb $32, %bl
0x0f, 0x84, 0x0c, 0x00, 0x00, 0x00, //0x0000075e je LBB0_95
0x80, 0xc3, 0xf7, //0x00000764 addb $-9, %bl
0x80, 0xfb, 0x01, //0x00000767 cmpb $1, %bl
0x0f, 0x87, 0xc5, 0x00, 0x00, 0x00, //0x0000076a ja LBB0_112
//0x00000770 .p2align 4, 0x90
//0x00000770 LBB0_95
0x49, 0x8d, 0x52, 0x02, //0x00000770 leaq $2(%r10), %rdx
0x48, 0x39, 0xc2, //0x00000774 cmpq %rax, %rdx
0x0f, 0x83, 0x23, 0x00, 0x00, 0x00, //0x00000777 jae LBB0_99
0x41, 0x8a, 0x5c, 0x15, 0x00, //0x0000077d movb (%r13,%rdx), %bl
0x80, 0xfb, 0x0d, //0x00000782 cmpb $13, %bl
0x0f, 0x84, 0x15, 0x00, 0x00, 0x00, //0x00000785 je LBB0_99
0x80, 0xfb, 0x20, //0x0000078b cmpb $32, %bl
0x0f, 0x84, 0x0c, 0x00, 0x00, 0x00, //0x0000078e je LBB0_99
0x80, 0xc3, 0xf7, //0x00000794 addb $-9, %bl
0x80, 0xfb, 0x01, //0x00000797 cmpb $1, %bl
0x0f, 0x87, 0x95, 0x00, 0x00, 0x00, //0x0000079a ja LBB0_112
//0x000007a0 .p2align 4, 0x90
//0x000007a0 LBB0_99
0x49, 0x8d, 0x52, 0x03, //0x000007a0 leaq $3(%r10), %rdx
0x48, 0x39, 0xc2, //0x000007a4 cmpq %rax, %rdx
0x0f, 0x83, 0x23, 0x00, 0x00, 0x00, //0x000007a7 jae LBB0_103
0x41, 0x8a, 0x5c, 0x15, 0x00, //0x000007ad movb (%r13,%rdx), %bl
0x80, 0xfb, 0x0d, //0x000007b2 cmpb $13, %bl
0x0f, 0x84, 0x15, 0x00, 0x00, 0x00, //0x000007b5 je LBB0_103
0x80, 0xfb, 0x20, //0x000007bb cmpb $32, %bl
0x0f, 0x84, 0x0c, 0x00, 0x00, 0x00, //0x000007be je LBB0_103
0x80, 0xc3, 0xf7, //0x000007c4 addb $-9, %bl
0x80, 0xfb, 0x01, //0x000007c7 cmpb $1, %bl
0x0f, 0x87, 0x65, 0x00, 0x00, 0x00, //0x000007ca ja LBB0_112
//0x000007d0 .p2align 4, 0x90
//0x000007d0 LBB0_103
0x49, 0x8d, 0x52, 0x04, //0x000007d0 leaq $4(%r10), %rdx
0x48, 0x39, 0xd0, //0x000007d4 cmpq %rdx, %rax
0x0f, 0x86, 0x08, 0x28, 0x00, 0x00, //0x000007d7 jbe LBB0_866
0x48, 0x39, 0xd0, //0x000007dd cmpq %rdx, %rax
0x0f, 0x84, 0x3a, 0x00, 0x00, 0x00, //0x000007e0 je LBB0_109
0x4a, 0x8d, 0x34, 0x28, //0x000007e6 leaq (%rax,%r13), %rsi
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x000007ea .p2align 4, 0x90
//0x000007f0 LBB0_106
0x41, 0x0f, 0xbe, 0x7c, 0x15, 0x00, //0x000007f0 movsbl (%r13,%rdx), %edi
0x83, 0xff, 0x20, //0x000007f6 cmpl $32, %edi
0x0f, 0x87, 0x2d, 0x00, 0x00, 0x00, //0x000007f9 ja LBB0_111
0x49, 0x0f, 0xa3, 0xf9, //0x000007ff btq %rdi, %r9
0x0f, 0x83, 0x23, 0x00, 0x00, 0x00, //0x00000803 jae LBB0_111
0x48, 0x83, 0xc2, 0x01, //0x00000809 addq $1, %rdx
0x48, 0x39, 0xd0, //0x0000080d cmpq %rdx, %rax
0x0f, 0x85, 0xda, 0xff, 0xff, 0xff, //0x00000810 jne LBB0_106
0xe9, 0x0b, 0x00, 0x00, 0x00, //0x00000816 jmp LBB0_110
0x90, 0x90, 0x90, 0x90, 0x90, //0x0000081b .p2align 4, 0x90
//0x00000820 LBB0_109
0x4c, 0x01, 0xea, //0x00000820 addq %r13, %rdx
0x48, 0x89, 0xd6, //0x00000823 movq %rdx, %rsi
//0x00000826 LBB0_110
0x4c, 0x29, 0xee, //0x00000826 subq %r13, %rsi
0x48, 0x89, 0xf2, //0x00000829 movq %rsi, %rdx
//0x0000082c LBB0_111
0x48, 0x39, 0xc2, //0x0000082c cmpq %rax, %rdx
0x0f, 0x83, 0x0e, 0x3e, 0x00, 0x00, //0x0000082f jae LBB0_868
//0x00000835 LBB0_112
0x4c, 0x8d, 0x52, 0x01, //0x00000835 leaq $1(%rdx), %r10
0x4d, 0x89, 0x10, //0x00000839 movq %r10, (%r8)
0x41, 0x80, 0x7c, 0x15, 0x00, 0x3a, //0x0000083c cmpb $58, (%r13,%rdx)
0x0f, 0x85, 0xfb, 0x3d, 0x00, 0x00, //0x00000842 jne LBB0_868
0x48, 0x85, 0xc9, //0x00000848 testq %rcx, %rcx
0x0f, 0x85, 0x8f, 0x25, 0x00, 0x00, //0x0000084b jne LBB0_458
0x49, 0x8b, 0x0f, //0x00000851 movq (%r15), %rcx
0x49, 0x39, 0xca, //0x00000854 cmpq %rcx, %r10
0x0f, 0x83, 0x33, 0x00, 0x00, 0x00, //0x00000857 jae LBB0_119
0x43, 0x8a, 0x44, 0x15, 0x00, //0x0000085d movb (%r13,%r10), %al
0x3c, 0x0d, //0x00000862 cmpb $13, %al
0x0f, 0x84, 0x26, 0x00, 0x00, 0x00, //0x00000864 je LBB0_119
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | true |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/parse_with_padding.go | vendor/github.com/bytedance/sonic/internal/native/sse/parse_with_padding.go | // Code generated by Makefile, DO NOT EDIT.
// 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
import (
`unsafe`
`github.com/bytedance/sonic/internal/rt`
)
var F_parse_with_padding func(parser unsafe.Pointer) (ret int)
var S_parse_with_padding uintptr
//go:nosplit
func parse_with_padding(parser unsafe.Pointer) (ret int) {
return F_parse_with_padding(rt.NoEscape(parser))
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/html_escape.go | vendor/github.com/bytedance/sonic/internal/native/sse/html_escape.go | // 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
import (
`unsafe`
`github.com/bytedance/sonic/internal/rt`
)
var F_html_escape func(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn unsafe.Pointer) (ret int)
var S_html_escape uintptr
//go:nosplit
func html_escape(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int) (ret int) {
return F_html_escape(rt.NoEscape(sp), nb, dp, rt.NoEscape(unsafe.Pointer(dn)))
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/validate_utf8.go | vendor/github.com/bytedance/sonic/internal/native/sse/validate_utf8.go | // 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
import (
`unsafe`
`github.com/bytedance/sonic/internal/native/types`
`github.com/bytedance/sonic/internal/rt`
)
var F_validate_utf8 func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer) (ret int)
var S_validate_utf8 uintptr
//go:nosplit
func validate_utf8(s *string, p *int, m *types.StateMachine) (ret int) {
return F_validate_utf8(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)))
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/skip_one_fast_subr.go | vendor/github.com/bytedance/sonic/internal/native/sse/skip_one_fast_subr.go | // +build !noasm !appengine
// Code generated by asm2asm, DO NOT EDIT.
package sse
import (
`github.com/bytedance/sonic/loader`
)
const (
_entry__skip_one_fast = 128
)
const (
_stack__skip_one_fast = 136
)
const (
_size__skip_one_fast = 3348
)
var (
_pcsp__skip_one_fast = [][2]uint32{
{0x1, 0},
{0x6, 8},
{0x8, 16},
{0xa, 24},
{0xc, 32},
{0xd, 40},
{0x11, 48},
{0x25c, 136},
{0x25d, 48},
{0x25f, 40},
{0x261, 32},
{0x263, 24},
{0x265, 16},
{0x266, 8},
{0x267, 0},
{0xd14, 136},
}
)
var _cfunc_skip_one_fast = []loader.CFunc{
{"_skip_one_fast_entry", 0, _entry__skip_one_fast, 0, nil},
{"_skip_one_fast", _entry__skip_one_fast, _size__skip_one_fast, _stack__skip_one_fast, _pcsp__skip_one_fast},
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/quote.go | vendor/github.com/bytedance/sonic/internal/native/sse/quote.go | // 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
import (
`unsafe`
`github.com/bytedance/sonic/internal/rt`
)
var F_quote func(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn unsafe.Pointer, flags uint64) (ret int)
var S_quote uintptr
//go:nosplit
func quote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int, flags uint64) (ret int) {
return F_quote(rt.NoEscape(sp), nb, rt.NoEscape(dp), rt.NoEscape(unsafe.Pointer(dn)), flags)
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/vnumber_subr.go | vendor/github.com/bytedance/sonic/internal/native/sse/vnumber_subr.go | // +build !noasm !appengine
// Code generated by asm2asm, DO NOT EDIT.
package sse
import (
`github.com/bytedance/sonic/loader`
)
const (
_entry__vnumber = 48
)
const (
_stack__vnumber = 136
)
const (
_size__vnumber = 7880
)
var (
_pcsp__vnumber = [][2]uint32{
{0x1, 0},
{0x6, 8},
{0x8, 16},
{0xa, 24},
{0xc, 32},
{0xd, 40},
{0x11, 48},
{0x1ebb, 136},
{0x1ebc, 48},
{0x1ebe, 40},
{0x1ec0, 32},
{0x1ec2, 24},
{0x1ec4, 16},
{0x1ec5, 8},
{0x1ec8, 0},
}
)
var _cfunc_vnumber = []loader.CFunc{
{"_vnumber_entry", 0, _entry__vnumber, 0, nil},
{"_vnumber", _entry__vnumber, _size__vnumber, _stack__vnumber, _pcsp__vnumber},
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/lspace_text_amd64.go | vendor/github.com/bytedance/sonic/internal/native/sse/lspace_text_amd64.go | // +build amd64
// Code generated by asm2asm, DO NOT EDIT.
package sse
var _text_lspace = []byte{
// .p2align 4, 0x90
// _lspace
0x55, // pushq %rbp
0x48, 0x89, 0xe5, //0x00000001 movq %rsp, %rbp
0x48, 0x89, 0xd0, //0x00000004 movq %rdx, %rax
0x48, 0x39, 0xd6, //0x00000007 cmpq %rdx, %rsi
0x0f, 0x84, 0x39, 0x00, 0x00, 0x00, //0x0000000a je LBB0_1
0x4c, 0x8d, 0x04, 0x37, //0x00000010 leaq (%rdi,%rsi), %r8
0x48, 0xba, 0x00, 0x26, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, //0x00000014 movabsq $4294977024, %rdx
0x90, 0x90, //0x0000001e .p2align 4, 0x90
//0x00000020 LBB0_3
0x0f, 0xbe, 0x0c, 0x07, //0x00000020 movsbl (%rdi,%rax), %ecx
0x83, 0xf9, 0x20, //0x00000024 cmpl $32, %ecx
0x0f, 0x87, 0x28, 0x00, 0x00, 0x00, //0x00000027 ja LBB0_7
0x48, 0x0f, 0xa3, 0xca, //0x0000002d btq %rcx, %rdx
0x0f, 0x83, 0x1e, 0x00, 0x00, 0x00, //0x00000031 jae LBB0_7
0x48, 0x83, 0xc0, 0x01, //0x00000037 addq $1, %rax
0x48, 0x39, 0xc6, //0x0000003b cmpq %rax, %rsi
0x0f, 0x85, 0xdc, 0xff, 0xff, 0xff, //0x0000003e jne LBB0_3
0xe9, 0x06, 0x00, 0x00, 0x00, //0x00000044 jmp LBB0_6
//0x00000049 LBB0_1
0x48, 0x01, 0xf8, //0x00000049 addq %rdi, %rax
0x49, 0x89, 0xc0, //0x0000004c movq %rax, %r8
//0x0000004f LBB0_6
0x49, 0x29, 0xf8, //0x0000004f subq %rdi, %r8
0x4c, 0x89, 0xc0, //0x00000052 movq %r8, %rax
//0x00000055 LBB0_7
0x5d, //0x00000055 popq %rbp
0xc3, //0x00000056 retq
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/validate_utf8_text_amd64.go | vendor/github.com/bytedance/sonic/internal/native/sse/validate_utf8_text_amd64.go | // +build amd64
// Code generated by asm2asm, DO NOT EDIT.
package sse
var _text_validate_utf8 = []byte{
// .p2align 4, 0x90
// _validate_utf8
0x55, // pushq %rbp
0x48, 0x89, 0xe5, //0x00000001 movq %rsp, %rbp
0x41, 0x57, //0x00000004 pushq %r15
0x41, 0x56, //0x00000006 pushq %r14
0x41, 0x54, //0x00000008 pushq %r12
0x53, //0x0000000a pushq %rbx
0x50, //0x0000000b pushq %rax
0x4c, 0x8b, 0x17, //0x0000000c movq (%rdi), %r10
0x4c, 0x8b, 0x5f, 0x08, //0x0000000f movq $8(%rdi), %r11
0x48, 0x8b, 0x0e, //0x00000013 movq (%rsi), %rcx
0x4c, 0x01, 0xd1, //0x00000016 addq %r10, %rcx
0x4f, 0x8d, 0x04, 0x1a, //0x00000019 leaq (%r10,%r11), %r8
0x49, 0x83, 0xc0, 0xfd, //0x0000001d addq $-3, %r8
0xe9, 0x0d, 0x00, 0x00, 0x00, //0x00000021 jmp LBB0_1
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000026 .p2align 4, 0x90
//0x00000030 LBB0_19
0x48, 0x01, 0xd9, //0x00000030 addq %rbx, %rcx
//0x00000033 LBB0_1
0x4c, 0x39, 0xc1, //0x00000033 cmpq %r8, %rcx
0x0f, 0x83, 0xe1, 0x00, 0x00, 0x00, //0x00000036 jae LBB0_2
0xbb, 0x01, 0x00, 0x00, 0x00, //0x0000003c movl $1, %ebx
0x80, 0x39, 0x00, //0x00000041 cmpb $0, (%rcx)
0x0f, 0x89, 0xe6, 0xff, 0xff, 0xff, //0x00000044 jns LBB0_19
0x8b, 0x01, //0x0000004a movl (%rcx), %eax
0x89, 0xc7, //0x0000004c movl %eax, %edi
0x81, 0xe7, 0xf0, 0xc0, 0xc0, 0x00, //0x0000004e andl $12632304, %edi
0x81, 0xff, 0xe0, 0x80, 0x80, 0x00, //0x00000054 cmpl $8421600, %edi
0x0f, 0x85, 0x30, 0x00, 0x00, 0x00, //0x0000005a jne LBB0_10
0x89, 0xc7, //0x00000060 movl %eax, %edi
0x81, 0xe7, 0x0f, 0x20, 0x00, 0x00, //0x00000062 andl $8207, %edi
0x81, 0xff, 0x0d, 0x20, 0x00, 0x00, //0x00000068 cmpl $8205, %edi
0x0f, 0x84, 0x1c, 0x00, 0x00, 0x00, //0x0000006e je LBB0_10
0xbb, 0x03, 0x00, 0x00, 0x00, //0x00000074 movl $3, %ebx
0x85, 0xff, //0x00000079 testl %edi, %edi
0x0f, 0x85, 0xaf, 0xff, 0xff, 0xff, //0x0000007b jne LBB0_19
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000081 .p2align 4, 0x90
//0x00000090 LBB0_10
0x89, 0xc7, //0x00000090 movl %eax, %edi
0x81, 0xe7, 0xe0, 0xc0, 0x00, 0x00, //0x00000092 andl $49376, %edi
0x81, 0xff, 0xc0, 0x80, 0x00, 0x00, //0x00000098 cmpl $32960, %edi
0x0f, 0x85, 0x10, 0x00, 0x00, 0x00, //0x0000009e jne LBB0_12
0x89, 0xc7, //0x000000a4 movl %eax, %edi
0xbb, 0x02, 0x00, 0x00, 0x00, //0x000000a6 movl $2, %ebx
0x83, 0xe7, 0x1e, //0x000000ab andl $30, %edi
0x0f, 0x85, 0x7c, 0xff, 0xff, 0xff, //0x000000ae jne LBB0_19
//0x000000b4 LBB0_12
0x89, 0xc7, //0x000000b4 movl %eax, %edi
0x81, 0xe7, 0xf8, 0xc0, 0xc0, 0xc0, //0x000000b6 andl $-1061109512, %edi
0x81, 0xff, 0xf0, 0x80, 0x80, 0x80, //0x000000bc cmpl $-2139062032, %edi
0x0f, 0x85, 0x26, 0x00, 0x00, 0x00, //0x000000c2 jne LBB0_16
0x89, 0xc7, //0x000000c8 movl %eax, %edi
0x81, 0xe7, 0x07, 0x30, 0x00, 0x00, //0x000000ca andl $12295, %edi
0x0f, 0x84, 0x18, 0x00, 0x00, 0x00, //0x000000d0 je LBB0_16
0xbb, 0x04, 0x00, 0x00, 0x00, //0x000000d6 movl $4, %ebx
0xa8, 0x04, //0x000000db testb $4, %al
0x0f, 0x84, 0x4d, 0xff, 0xff, 0xff, //0x000000dd je LBB0_19
0x25, 0x03, 0x30, 0x00, 0x00, //0x000000e3 andl $12291, %eax
0x0f, 0x84, 0x42, 0xff, 0xff, 0xff, //0x000000e8 je LBB0_19
//0x000000ee LBB0_16
0x48, 0x89, 0xcf, //0x000000ee movq %rcx, %rdi
0x4c, 0x29, 0xd7, //0x000000f1 subq %r10, %rdi
0x48, 0x8b, 0x1a, //0x000000f4 movq (%rdx), %rbx
0x48, 0x81, 0xfb, 0x00, 0x10, 0x00, 0x00, //0x000000f7 cmpq $4096, %rbx
0x0f, 0x83, 0x97, 0x01, 0x00, 0x00, //0x000000fe jae LBB0_17
0x48, 0x63, 0xc7, //0x00000104 movslq %edi, %rax
0x48, 0x8d, 0x7b, 0x01, //0x00000107 leaq $1(%rbx), %rdi
0x48, 0x89, 0x3a, //0x0000010b movq %rdi, (%rdx)
0x48, 0x89, 0x44, 0xda, 0x08, //0x0000010e movq %rax, $8(%rdx,%rbx,8)
0xbb, 0x01, 0x00, 0x00, 0x00, //0x00000113 movl $1, %ebx
0xe9, 0x13, 0xff, 0xff, 0xff, //0x00000118 jmp LBB0_19
//0x0000011d LBB0_2
0x4d, 0x01, 0xd3, //0x0000011d addq %r10, %r11
0x4c, 0x39, 0xd9, //0x00000120 cmpq %r11, %rcx
0x0f, 0x83, 0x4e, 0x01, 0x00, 0x00, //0x00000123 jae LBB0_36
0x4c, 0x8d, 0x45, 0xdc, //0x00000129 leaq $-36(%rbp), %r8
0x4c, 0x8d, 0x4d, 0xda, //0x0000012d leaq $-38(%rbp), %r9
0xe9, 0x17, 0x00, 0x00, 0x00, //0x00000131 jmp LBB0_4
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000136 .p2align 4, 0x90
//0x00000140 LBB0_5
0x48, 0x83, 0xc1, 0x01, //0x00000140 addq $1, %rcx
0x4c, 0x39, 0xd9, //0x00000144 cmpq %r11, %rcx
0x0f, 0x83, 0x2a, 0x01, 0x00, 0x00, //0x00000147 jae LBB0_36
//0x0000014d LBB0_4
0x80, 0x39, 0x00, //0x0000014d cmpb $0, (%rcx)
0x0f, 0x89, 0xea, 0xff, 0xff, 0xff, //0x00000150 jns LBB0_5
0xc6, 0x45, 0xdc, 0x00, //0x00000156 movb $0, $-36(%rbp)
0xc6, 0x45, 0xda, 0x00, //0x0000015a movb $0, $-38(%rbp)
0x4c, 0x89, 0xdb, //0x0000015e movq %r11, %rbx
0x48, 0x29, 0xcb, //0x00000161 subq %rcx, %rbx
0x48, 0x83, 0xfb, 0x02, //0x00000164 cmpq $2, %rbx
0x0f, 0x82, 0x35, 0x00, 0x00, 0x00, //0x00000168 jb LBB0_21
0x44, 0x0f, 0xb6, 0x21, //0x0000016e movzbl (%rcx), %r12d
0x44, 0x0f, 0xb6, 0x71, 0x01, //0x00000172 movzbl $1(%rcx), %r14d
0x44, 0x88, 0x65, 0xdc, //0x00000177 movb %r12b, $-36(%rbp)
0x4c, 0x8d, 0x79, 0x02, //0x0000017b leaq $2(%rcx), %r15
0x48, 0x83, 0xc3, 0xfe, //0x0000017f addq $-2, %rbx
0x4c, 0x89, 0xcf, //0x00000183 movq %r9, %rdi
0x48, 0x85, 0xdb, //0x00000186 testq %rbx, %rbx
0x0f, 0x84, 0x29, 0x00, 0x00, 0x00, //0x00000189 je LBB0_24
//0x0000018f LBB0_25
0x41, 0x0f, 0xb6, 0x07, //0x0000018f movzbl (%r15), %eax
0x88, 0x07, //0x00000193 movb %al, (%rdi)
0x44, 0x0f, 0xb6, 0x65, 0xdc, //0x00000195 movzbl $-36(%rbp), %r12d
0x0f, 0xb6, 0x7d, 0xda, //0x0000019a movzbl $-38(%rbp), %edi
0xe9, 0x17, 0x00, 0x00, 0x00, //0x0000019e jmp LBB0_26
//0x000001a3 LBB0_21
0x45, 0x31, 0xe4, //0x000001a3 xorl %r12d, %r12d
0x45, 0x31, 0xf6, //0x000001a6 xorl %r14d, %r14d
0x4c, 0x89, 0xc7, //0x000001a9 movq %r8, %rdi
0x49, 0x89, 0xcf, //0x000001ac movq %rcx, %r15
0x48, 0x85, 0xdb, //0x000001af testq %rbx, %rbx
0x0f, 0x85, 0xd7, 0xff, 0xff, 0xff, //0x000001b2 jne LBB0_25
//0x000001b8 LBB0_24
0x31, 0xff, //0x000001b8 xorl %edi, %edi
//0x000001ba LBB0_26
0x40, 0x0f, 0xb6, 0xc7, //0x000001ba movzbl %dil, %eax
0xc1, 0xe0, 0x10, //0x000001be shll $16, %eax
0x41, 0x0f, 0xb6, 0xde, //0x000001c1 movzbl %r14b, %ebx
0xc1, 0xe3, 0x08, //0x000001c5 shll $8, %ebx
0x09, 0xc3, //0x000001c8 orl %eax, %ebx
0x41, 0x0f, 0xb6, 0xfc, //0x000001ca movzbl %r12b, %edi
0x09, 0xdf, //0x000001ce orl %ebx, %edi
0x89, 0xf8, //0x000001d0 movl %edi, %eax
0x25, 0xf0, 0xc0, 0xc0, 0x00, //0x000001d2 andl $12632304, %eax
0x3d, 0xe0, 0x80, 0x80, 0x00, //0x000001d7 cmpl $8421600, %eax
0x0f, 0x85, 0x2e, 0x00, 0x00, 0x00, //0x000001dc jne LBB0_29
0x89, 0xf8, //0x000001e2 movl %edi, %eax
0x25, 0x0f, 0x20, 0x00, 0x00, //0x000001e4 andl $8207, %eax
0x3d, 0x0d, 0x20, 0x00, 0x00, //0x000001e9 cmpl $8205, %eax
0x0f, 0x84, 0x1c, 0x00, 0x00, 0x00, //0x000001ee je LBB0_29
0xbb, 0x03, 0x00, 0x00, 0x00, //0x000001f4 movl $3, %ebx
0x85, 0xc0, //0x000001f9 testl %eax, %eax
0x0f, 0x85, 0x30, 0x00, 0x00, 0x00, //0x000001fb jne LBB0_34
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000201 .p2align 4, 0x90
//0x00000210 LBB0_29
0x41, 0xf6, 0xc4, 0x1e, //0x00000210 testb $30, %r12b
0x0f, 0x84, 0x28, 0x00, 0x00, 0x00, //0x00000214 je LBB0_31
0x81, 0xe7, 0xe0, 0xc0, 0x00, 0x00, //0x0000021a andl $49376, %edi
0xbb, 0x02, 0x00, 0x00, 0x00, //0x00000220 movl $2, %ebx
0x81, 0xff, 0xc0, 0x80, 0x00, 0x00, //0x00000225 cmpl $32960, %edi
0x0f, 0x85, 0x11, 0x00, 0x00, 0x00, //0x0000022b jne LBB0_31
//0x00000231 LBB0_34
0x48, 0x01, 0xd9, //0x00000231 addq %rbx, %rcx
0x4c, 0x39, 0xd9, //0x00000234 cmpq %r11, %rcx
0x0f, 0x82, 0x10, 0xff, 0xff, 0xff, //0x00000237 jb LBB0_4
0xe9, 0x35, 0x00, 0x00, 0x00, //0x0000023d jmp LBB0_36
//0x00000242 LBB0_31
0x48, 0x89, 0xc8, //0x00000242 movq %rcx, %rax
0x4c, 0x29, 0xd0, //0x00000245 subq %r10, %rax
0x48, 0x8b, 0x3a, //0x00000248 movq (%rdx), %rdi
0x48, 0x81, 0xff, 0x00, 0x10, 0x00, 0x00, //0x0000024b cmpq $4096, %rdi
0x0f, 0x83, 0x34, 0x00, 0x00, 0x00, //0x00000252 jae LBB0_32
0x48, 0x98, //0x00000258 cltq
0x48, 0x8d, 0x5f, 0x01, //0x0000025a leaq $1(%rdi), %rbx
0x48, 0x89, 0x1a, //0x0000025e movq %rbx, (%rdx)
0x48, 0x89, 0x44, 0xfa, 0x08, //0x00000261 movq %rax, $8(%rdx,%rdi,8)
0xbb, 0x01, 0x00, 0x00, 0x00, //0x00000266 movl $1, %ebx
0x48, 0x01, 0xd9, //0x0000026b addq %rbx, %rcx
0x4c, 0x39, 0xd9, //0x0000026e cmpq %r11, %rcx
0x0f, 0x82, 0xd6, 0xfe, 0xff, 0xff, //0x00000271 jb LBB0_4
//0x00000277 LBB0_36
0x4c, 0x29, 0xd1, //0x00000277 subq %r10, %rcx
0x48, 0x89, 0x0e, //0x0000027a movq %rcx, (%rsi)
0x31, 0xc0, //0x0000027d xorl %eax, %eax
//0x0000027f LBB0_37
0x48, 0x83, 0xc4, 0x08, //0x0000027f addq $8, %rsp
0x5b, //0x00000283 popq %rbx
0x41, 0x5c, //0x00000284 popq %r12
0x41, 0x5e, //0x00000286 popq %r14
0x41, 0x5f, //0x00000288 popq %r15
0x5d, //0x0000028a popq %rbp
0xc3, //0x0000028b retq
//0x0000028c LBB0_32
0x48, 0x89, 0x06, //0x0000028c movq %rax, (%rsi)
0x48, 0xc7, 0xc0, 0xff, 0xff, 0xff, 0xff, //0x0000028f movq $-1, %rax
0xe9, 0xe4, 0xff, 0xff, 0xff, //0x00000296 jmp LBB0_37
//0x0000029b LBB0_17
0x48, 0x89, 0x3e, //0x0000029b movq %rdi, (%rsi)
0x48, 0xc7, 0xc0, 0xff, 0xff, 0xff, 0xff, //0x0000029e movq $-1, %rax
0xe9, 0xd5, 0xff, 0xff, 0xff, //0x000002a5 jmp LBB0_37
0x00, 0x00, //0x000002aa .p2align 2, 0x00
//0x000002ac _MASK_USE_NUMBER
0x02, 0x00, 0x00, 0x00, //0x000002ac .long 2
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/validate_one_subr.go | vendor/github.com/bytedance/sonic/internal/native/sse/validate_one_subr.go | // +build !noasm !appengine
// Code generated by asm2asm, DO NOT EDIT.
package sse
import (
`github.com/bytedance/sonic/loader`
)
const (
_entry__validate_one = 256
)
const (
_stack__validate_one = 184
)
const (
_size__validate_one = 15328
)
var (
_pcsp__validate_one = [][2]uint32{
{0x1, 0},
{0x6, 8},
{0x8, 16},
{0xa, 24},
{0xc, 32},
{0xd, 40},
{0x14, 48},
{0x394e, 184},
{0x394f, 48},
{0x3951, 40},
{0x3953, 32},
{0x3955, 24},
{0x3957, 16},
{0x3958, 8},
{0x3959, 0},
{0x3be0, 184},
}
)
var _cfunc_validate_one = []loader.CFunc{
{"_validate_one_entry", 0, _entry__validate_one, 0, nil},
{"_validate_one", _entry__validate_one, _size__validate_one, _stack__validate_one, _pcsp__validate_one},
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/skip_number_subr.go | vendor/github.com/bytedance/sonic/internal/native/sse/skip_number_subr.go | // +build !noasm !appengine
// Code generated by asm2asm, DO NOT EDIT.
package sse
import (
`github.com/bytedance/sonic/loader`
)
const (
_entry__skip_number = 112
)
const (
_stack__skip_number = 72
)
const (
_size__skip_number = 1060
)
var (
_pcsp__skip_number = [][2]uint32{
{0x1, 0},
{0x6, 8},
{0x8, 16},
{0xa, 24},
{0xc, 32},
{0xd, 40},
{0x11, 48},
{0x373, 72},
{0x374, 48},
{0x376, 40},
{0x378, 32},
{0x37a, 24},
{0x37c, 16},
{0x37d, 8},
{0x37e, 0},
{0x424, 72},
}
)
var _cfunc_skip_number = []loader.CFunc{
{"_skip_number_entry", 0, _entry__skip_number, 0, nil},
{"_skip_number", _entry__skip_number, _size__skip_number, _stack__skip_number, _pcsp__skip_number},
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/skip_one_subr.go | vendor/github.com/bytedance/sonic/internal/native/sse/skip_one_subr.go | // +build !noasm !appengine
// Code generated by asm2asm, DO NOT EDIT.
package sse
import (
`github.com/bytedance/sonic/loader`
)
const (
_entry__skip_one = 256
)
const (
_stack__skip_one = 232
)
const (
_size__skip_one = 13880
)
var (
_pcsp__skip_one = [][2]uint32{
{0x1, 0},
{0x6, 8},
{0x8, 16},
{0xa, 24},
{0xc, 32},
{0xd, 40},
{0x14, 48},
{0x3330, 232},
{0x3331, 48},
{0x3333, 40},
{0x3335, 32},
{0x3337, 24},
{0x3339, 16},
{0x333a, 8},
{0x333b, 0},
{0x3638, 232},
}
)
var _cfunc_skip_one = []loader.CFunc{
{"_skip_one_entry", 0, _entry__skip_one, 0, nil},
{"_skip_one", _entry__skip_one, _size__skip_one, _stack__skip_one, _pcsp__skip_one},
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/skip_one.go | vendor/github.com/bytedance/sonic/internal/native/sse/skip_one.go | // 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
import (
`unsafe`
`github.com/bytedance/sonic/internal/native/types`
`github.com/bytedance/sonic/internal/rt`
)
var F_skip_one func(s unsafe.Pointer, p unsafe.Pointer, m unsafe.Pointer, flags uint64) (ret int)
var S_skip_one uintptr
//go:nosplit
func skip_one(s *string, p *int, m *types.StateMachine, flags uint64) (ret int) {
return F_skip_one(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(m)), flags)
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/vsigned_subr.go | vendor/github.com/bytedance/sonic/internal/native/sse/vsigned_subr.go | // +build !noasm !appengine
// Code generated by asm2asm, DO NOT EDIT.
package sse
import (
`github.com/bytedance/sonic/loader`
)
const (
_entry__vsigned = 0
)
const (
_stack__vsigned = 16
)
const (
_size__vsigned = 356
)
var (
_pcsp__vsigned = [][2]uint32{
{0x1, 0},
{0x5, 8},
{0x70, 16},
{0x71, 8},
{0x72, 0},
{0x7d, 16},
{0x7e, 8},
{0x7f, 0},
{0x117, 16},
{0x118, 8},
{0x119, 0},
{0x11d, 16},
{0x11e, 8},
{0x11f, 0},
{0x155, 16},
{0x156, 8},
{0x157, 0},
{0x162, 16},
{0x163, 8},
{0x164, 0},
}
)
var _cfunc_vsigned = []loader.CFunc{
{"_vsigned_entry", 0, _entry__vsigned, 0, nil},
{"_vsigned", _entry__vsigned, _size__vsigned, _stack__vsigned, _pcsp__vsigned},
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/vunsigned_text_amd64.go | vendor/github.com/bytedance/sonic/internal/native/sse/vunsigned_text_amd64.go | // +build amd64
// Code generated by asm2asm, DO NOT EDIT.
package sse
var _text_vunsigned = []byte{
// .p2align 4, 0x90
// _vunsigned
0x55, // pushq %rbp
0x48, 0x89, 0xe5, //0x00000001 movq %rsp, %rbp
0x41, 0x56, //0x00000004 pushq %r14
0x53, //0x00000006 pushq %rbx
0x49, 0x89, 0xd0, //0x00000007 movq %rdx, %r8
0x48, 0x8b, 0x0e, //0x0000000a movq (%rsi), %rcx
0x4c, 0x8b, 0x0f, //0x0000000d movq (%rdi), %r9
0x4c, 0x8b, 0x77, 0x08, //0x00000010 movq $8(%rdi), %r14
0x48, 0xc7, 0x02, 0x09, 0x00, 0x00, 0x00, //0x00000014 movq $9, (%rdx)
0x0f, 0x57, 0xc0, //0x0000001b xorps %xmm0, %xmm0
0x0f, 0x11, 0x42, 0x08, //0x0000001e movups %xmm0, $8(%rdx)
0x48, 0x8b, 0x06, //0x00000022 movq (%rsi), %rax
0x48, 0x89, 0x42, 0x18, //0x00000025 movq %rax, $24(%rdx)
0x4c, 0x39, 0xf1, //0x00000029 cmpq %r14, %rcx
0x0f, 0x83, 0x1b, 0x00, 0x00, 0x00, //0x0000002c jae LBB0_1
0x41, 0x8a, 0x04, 0x09, //0x00000032 movb (%r9,%rcx), %al
0x3c, 0x2d, //0x00000036 cmpb $45, %al
0x0f, 0x85, 0x1e, 0x00, 0x00, 0x00, //0x00000038 jne LBB0_4
//0x0000003e LBB0_3
0x48, 0x89, 0x0e, //0x0000003e movq %rcx, (%rsi)
0x49, 0xc7, 0x00, 0xfa, 0xff, 0xff, 0xff, //0x00000041 movq $-6, (%r8)
0x5b, //0x00000048 popq %rbx
0x41, 0x5e, //0x00000049 popq %r14
0x5d, //0x0000004b popq %rbp
0xc3, //0x0000004c retq
//0x0000004d LBB0_1
0x4c, 0x89, 0x36, //0x0000004d movq %r14, (%rsi)
0x49, 0xc7, 0x00, 0xff, 0xff, 0xff, 0xff, //0x00000050 movq $-1, (%r8)
0x5b, //0x00000057 popq %rbx
0x41, 0x5e, //0x00000058 popq %r14
0x5d, //0x0000005a popq %rbp
0xc3, //0x0000005b retq
//0x0000005c LBB0_4
0x8d, 0x50, 0xd0, //0x0000005c leal $-48(%rax), %edx
0x80, 0xfa, 0x0a, //0x0000005f cmpb $10, %dl
0x0f, 0x82, 0x0f, 0x00, 0x00, 0x00, //0x00000062 jb LBB0_6
0x48, 0x89, 0x0e, //0x00000068 movq %rcx, (%rsi)
0x49, 0xc7, 0x00, 0xfe, 0xff, 0xff, 0xff, //0x0000006b movq $-2, (%r8)
0x5b, //0x00000072 popq %rbx
0x41, 0x5e, //0x00000073 popq %r14
0x5d, //0x00000075 popq %rbp
0xc3, //0x00000076 retq
//0x00000077 LBB0_6
0x3c, 0x30, //0x00000077 cmpb $48, %al
0x0f, 0x85, 0x26, 0x00, 0x00, 0x00, //0x00000079 jne LBB0_10
0x41, 0x8a, 0x44, 0x09, 0x01, //0x0000007f movb $1(%r9,%rcx), %al
0x04, 0xd2, //0x00000084 addb $-46, %al
0x3c, 0x37, //0x00000086 cmpb $55, %al
0x0f, 0x87, 0xc7, 0x00, 0x00, 0x00, //0x00000088 ja LBB0_9
0x0f, 0xb6, 0xc0, //0x0000008e movzbl %al, %eax
0x48, 0xba, 0x01, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, //0x00000091 movabsq $36028797027352577, %rdx
0x48, 0x0f, 0xa3, 0xc2, //0x0000009b btq %rax, %rdx
0x0f, 0x83, 0xb0, 0x00, 0x00, 0x00, //0x0000009f jae LBB0_9
//0x000000a5 LBB0_10
0x49, 0x39, 0xce, //0x000000a5 cmpq %rcx, %r14
0x49, 0x89, 0xca, //0x000000a8 movq %rcx, %r10
0x4d, 0x0f, 0x47, 0xd6, //0x000000ab cmovaq %r14, %r10
0x31, 0xc0, //0x000000af xorl %eax, %eax
0x41, 0xbb, 0x0a, 0x00, 0x00, 0x00, //0x000000b1 movl $10, %r11d
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x000000b7 .p2align 4, 0x90
//0x000000c0 LBB0_11
0x49, 0x39, 0xca, //0x000000c0 cmpq %rcx, %r10
0x0f, 0x84, 0x80, 0x00, 0x00, 0x00, //0x000000c3 je LBB0_22
0x41, 0x0f, 0xbe, 0x1c, 0x09, //0x000000c9 movsbl (%r9,%rcx), %ebx
0x8d, 0x53, 0xd0, //0x000000ce leal $-48(%rbx), %edx
0x80, 0xfa, 0x09, //0x000000d1 cmpb $9, %dl
0x0f, 0x87, 0x44, 0x00, 0x00, 0x00, //0x000000d4 ja LBB0_17
0x49, 0xf7, 0xe3, //0x000000da mulq %r11
0x0f, 0x80, 0x28, 0x00, 0x00, 0x00, //0x000000dd jo LBB0_16
0x48, 0x83, 0xc1, 0x01, //0x000000e3 addq $1, %rcx
0x83, 0xc3, 0xd0, //0x000000e7 addl $-48, %ebx
0x31, 0xff, //0x000000ea xorl %edi, %edi
0x48, 0x01, 0xd8, //0x000000ec addq %rbx, %rax
0x40, 0x0f, 0x92, 0xc7, //0x000000ef setb %dil
0x48, 0x89, 0xfa, //0x000000f3 movq %rdi, %rdx
0x48, 0xf7, 0xda, //0x000000f6 negq %rdx
0x48, 0x31, 0xd7, //0x000000f9 xorq %rdx, %rdi
0x0f, 0x85, 0x09, 0x00, 0x00, 0x00, //0x000000fc jne LBB0_16
0x48, 0x85, 0xd2, //0x00000102 testq %rdx, %rdx
0x0f, 0x89, 0xb5, 0xff, 0xff, 0xff, //0x00000105 jns LBB0_11
//0x0000010b LBB0_16
0x48, 0x83, 0xc1, 0xff, //0x0000010b addq $-1, %rcx
0x48, 0x89, 0x0e, //0x0000010f movq %rcx, (%rsi)
0x49, 0xc7, 0x00, 0xfb, 0xff, 0xff, 0xff, //0x00000112 movq $-5, (%r8)
0x5b, //0x00000119 popq %rbx
0x41, 0x5e, //0x0000011a popq %r14
0x5d, //0x0000011c popq %rbp
0xc3, //0x0000011d retq
//0x0000011e LBB0_17
0x4c, 0x39, 0xf1, //0x0000011e cmpq %r14, %rcx
0x0f, 0x83, 0x1f, 0x00, 0x00, 0x00, //0x00000121 jae LBB0_21
0x41, 0x8a, 0x14, 0x09, //0x00000127 movb (%r9,%rcx), %dl
0x80, 0xfa, 0x2e, //0x0000012b cmpb $46, %dl
0x0f, 0x84, 0x0a, 0xff, 0xff, 0xff, //0x0000012e je LBB0_3
0x80, 0xfa, 0x45, //0x00000134 cmpb $69, %dl
0x0f, 0x84, 0x01, 0xff, 0xff, 0xff, //0x00000137 je LBB0_3
0x80, 0xfa, 0x65, //0x0000013d cmpb $101, %dl
0x0f, 0x84, 0xf8, 0xfe, 0xff, 0xff, //0x00000140 je LBB0_3
//0x00000146 LBB0_21
0x49, 0x89, 0xca, //0x00000146 movq %rcx, %r10
//0x00000149 LBB0_22
0x4c, 0x89, 0x16, //0x00000149 movq %r10, (%rsi)
0x49, 0x89, 0x40, 0x10, //0x0000014c movq %rax, $16(%r8)
0x5b, //0x00000150 popq %rbx
0x41, 0x5e, //0x00000151 popq %r14
0x5d, //0x00000153 popq %rbp
0xc3, //0x00000154 retq
//0x00000155 LBB0_9
0x48, 0x83, 0xc1, 0x01, //0x00000155 addq $1, %rcx
0x48, 0x89, 0x0e, //0x00000159 movq %rcx, (%rsi)
0x5b, //0x0000015c popq %rbx
0x41, 0x5e, //0x0000015d popq %r14
0x5d, //0x0000015f popq %rbp
0xc3, //0x00000160 retq
0x00, 0x00, 0x00, //0x00000161 .p2align 2, 0x00
//0x00000164 _MASK_USE_NUMBER
0x02, 0x00, 0x00, 0x00, //0x00000164 .long 2
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/lookup_small_key_text_amd64.go | vendor/github.com/bytedance/sonic/internal/native/sse/lookup_small_key_text_amd64.go | // +build amd64
// Code generated by asm2asm, DO NOT EDIT.
package sse
var _text_lookup_small_key = []byte{
// .p2align 4, 0x00
// LCPI0_0
0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // QUAD $0x4040404040404040; QUAD $0x4040404040404040 // .space 16, '@@@@@@@@@@@@@@@@'
//0x00000010 LCPI0_1
0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, //0x00000010 QUAD $0x5b5b5b5b5b5b5b5b; QUAD $0x5b5b5b5b5b5b5b5b // .space 16, '[[[[[[[[[[[[[[[['
//0x00000020 LCPI0_2
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, //0x00000020 QUAD $0x0101010101010101; QUAD $0x0101010101010101 // .space 16, '\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01'
//0x00000030 .p2align 4, 0x90
//0x00000030 _lookup_small_key
0x55, //0x00000030 pushq %rbp
0x48, 0x89, 0xe5, //0x00000031 movq %rsp, %rbp
0x41, 0x57, //0x00000034 pushq %r15
0x41, 0x56, //0x00000036 pushq %r14
0x41, 0x55, //0x00000038 pushq %r13
0x41, 0x54, //0x0000003a pushq %r12
0x53, //0x0000003c pushq %rbx
0x48, 0x83, 0xec, 0x28, //0x0000003d subq $40, %rsp
0x4c, 0x8b, 0x57, 0x08, //0x00000041 movq $8(%rdi), %r10
0x4c, 0x8b, 0x1e, //0x00000045 movq (%rsi), %r11
0x45, 0x0f, 0xb6, 0xc2, //0x00000048 movzbl %r10b, %r8d
0x4b, 0x8d, 0x0c, 0x80, //0x0000004c leaq (%r8,%r8,4), %rcx
0x45, 0x0f, 0xb6, 0x0c, 0x0b, //0x00000050 movzbl (%r11,%rcx), %r9d
0x48, 0xc7, 0xc0, 0xff, 0xff, 0xff, 0xff, //0x00000055 movq $-1, %rax
0x45, 0x85, 0xc9, //0x0000005c testl %r9d, %r9d
0x0f, 0x84, 0x29, 0x03, 0x00, 0x00, //0x0000005f je LBB0_40
0x4c, 0x8b, 0x3f, //0x00000065 movq (%rdi), %r15
0x41, 0x8b, 0x44, 0x0b, 0x01, //0x00000068 movl $1(%r11,%rcx), %eax
0x8d, 0xb0, 0xa5, 0x00, 0x00, 0x00, //0x0000006d leal $165(%rax), %esi
0x4c, 0x01, 0xde, //0x00000073 addq %r11, %rsi
0x41, 0x0f, 0xb6, 0xca, //0x00000076 movzbl %r10b, %ecx
0x41, 0x83, 0xf8, 0x09, //0x0000007a cmpl $9, %r8d
0x48, 0x89, 0x55, 0xb0, //0x0000007e movq %rdx, $-80(%rbp)
0x48, 0x89, 0x45, 0xb8, //0x00000082 movq %rax, $-72(%rbp)
0x0f, 0x83, 0xd0, 0x00, 0x00, 0x00, //0x00000086 jae LBB0_2
0x45, 0x8a, 0x27, //0x0000008c movb (%r15), %r12b
0x45, 0x8d, 0x68, 0x01, //0x0000008f leal $1(%r8), %r13d
0x44, 0x89, 0xcb, //0x00000093 movl %r9d, %ebx
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000096 .p2align 4, 0x90
//0x000000a0 LBB0_7
0x44, 0x38, 0x26, //0x000000a0 cmpb %r12b, (%rsi)
0x0f, 0x85, 0x97, 0x00, 0x00, 0x00, //0x000000a3 jne LBB0_8
0x44, 0x0f, 0xb6, 0x76, 0x01, //0x000000a9 movzbl $1(%rsi), %r14d
0xbf, 0x01, 0x00, 0x00, 0x00, //0x000000ae movl $1, %edi
0x45, 0x3a, 0x77, 0x01, //0x000000b3 cmpb $1(%r15), %r14b
0x0f, 0x85, 0x85, 0x00, 0x00, 0x00, //0x000000b7 jne LBB0_16
0x0f, 0xb6, 0x56, 0x02, //0x000000bd movzbl $2(%rsi), %edx
0xbf, 0x02, 0x00, 0x00, 0x00, //0x000000c1 movl $2, %edi
0x41, 0x3a, 0x57, 0x02, //0x000000c6 cmpb $2(%r15), %dl
0x0f, 0x85, 0x72, 0x00, 0x00, 0x00, //0x000000ca jne LBB0_16
0x0f, 0xb6, 0x56, 0x03, //0x000000d0 movzbl $3(%rsi), %edx
0xbf, 0x03, 0x00, 0x00, 0x00, //0x000000d4 movl $3, %edi
0x41, 0x3a, 0x57, 0x03, //0x000000d9 cmpb $3(%r15), %dl
0x0f, 0x85, 0x5f, 0x00, 0x00, 0x00, //0x000000dd jne LBB0_16
0x0f, 0xb6, 0x56, 0x04, //0x000000e3 movzbl $4(%rsi), %edx
0xbf, 0x04, 0x00, 0x00, 0x00, //0x000000e7 movl $4, %edi
0x41, 0x3a, 0x57, 0x04, //0x000000ec cmpb $4(%r15), %dl
0x0f, 0x85, 0x4c, 0x00, 0x00, 0x00, //0x000000f0 jne LBB0_16
0x0f, 0xb6, 0x56, 0x05, //0x000000f6 movzbl $5(%rsi), %edx
0xbf, 0x05, 0x00, 0x00, 0x00, //0x000000fa movl $5, %edi
0x41, 0x3a, 0x57, 0x05, //0x000000ff cmpb $5(%r15), %dl
0x0f, 0x85, 0x39, 0x00, 0x00, 0x00, //0x00000103 jne LBB0_16
0x0f, 0xb6, 0x56, 0x06, //0x00000109 movzbl $6(%rsi), %edx
0xbf, 0x06, 0x00, 0x00, 0x00, //0x0000010d movl $6, %edi
0x41, 0x3a, 0x57, 0x06, //0x00000112 cmpb $6(%r15), %dl
0x0f, 0x85, 0x26, 0x00, 0x00, 0x00, //0x00000116 jne LBB0_16
0x0f, 0xb6, 0x56, 0x07, //0x0000011c movzbl $7(%rsi), %edx
0x31, 0xff, //0x00000120 xorl %edi, %edi
0x41, 0x3a, 0x57, 0x07, //0x00000122 cmpb $7(%r15), %dl
0x40, 0x0f, 0x94, 0xc7, //0x00000126 sete %dil
0x48, 0x83, 0xc7, 0x07, //0x0000012a addq $7, %rdi
0xe9, 0x0f, 0x00, 0x00, 0x00, //0x0000012e jmp LBB0_16
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000133 .p2align 4, 0x90
//0x00000140 LBB0_8
0x31, 0xff, //0x00000140 xorl %edi, %edi
//0x00000142 LBB0_16
0x48, 0x39, 0xcf, //0x00000142 cmpq %rcx, %rdi
0x0f, 0x83, 0xa1, 0x01, 0x00, 0x00, //0x00000145 jae LBB0_17
0x4c, 0x01, 0xee, //0x0000014b addq %r13, %rsi
0x83, 0xc3, 0xff, //0x0000014e addl $-1, %ebx
0x0f, 0x85, 0x49, 0xff, 0xff, 0xff, //0x00000151 jne LBB0_7
0xe9, 0x59, 0x00, 0x00, 0x00, //0x00000157 jmp LBB0_20
//0x0000015c LBB0_2
0xf3, 0x41, 0x0f, 0x6f, 0x07, //0x0000015c movdqu (%r15), %xmm0
0xf3, 0x41, 0x0f, 0x6f, 0x4f, 0x10, //0x00000161 movdqu $16(%r15), %xmm1
0x48, 0xc7, 0xc7, 0xff, 0xff, 0xff, 0xff, //0x00000167 movq $-1, %rdi
0x48, 0xd3, 0xe7, //0x0000016e shlq %cl, %rdi
0x45, 0x8d, 0x60, 0x01, //0x00000171 leal $1(%r8), %r12d
0x44, 0x89, 0xcb, //0x00000175 movl %r9d, %ebx
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000178 .p2align 4, 0x90
//0x00000180 LBB0_3
0xf3, 0x0f, 0x6f, 0x16, //0x00000180 movdqu (%rsi), %xmm2
0x66, 0x0f, 0x74, 0xd0, //0x00000184 pcmpeqb %xmm0, %xmm2
0xf3, 0x0f, 0x6f, 0x5e, 0x10, //0x00000188 movdqu $16(%rsi), %xmm3
0x66, 0x0f, 0x74, 0xd9, //0x0000018d pcmpeqb %xmm1, %xmm3
0x66, 0x0f, 0xd7, 0xd2, //0x00000191 pmovmskb %xmm2, %edx
0x66, 0x0f, 0xd7, 0xc3, //0x00000195 pmovmskb %xmm3, %eax
0xc1, 0xe0, 0x10, //0x00000199 shll $16, %eax
0x09, 0xd0, //0x0000019c orl %edx, %eax
0x09, 0xf8, //0x0000019e orl %edi, %eax
0x83, 0xf8, 0xff, //0x000001a0 cmpl $-1, %eax
0x0f, 0x84, 0x52, 0x01, 0x00, 0x00, //0x000001a3 je LBB0_4
0x4c, 0x01, 0xe6, //0x000001a9 addq %r12, %rsi
0x83, 0xc3, 0xff, //0x000001ac addl $-1, %ebx
0x0f, 0x85, 0xcb, 0xff, 0xff, 0xff, //0x000001af jne LBB0_3
//0x000001b5 LBB0_20
0x48, 0x8b, 0x45, 0xb0, //0x000001b5 movq $-80(%rbp), %rax
0x48, 0x83, 0xf8, 0xff, //0x000001b9 cmpq $-1, %rax
0x0f, 0x84, 0xc4, 0x01, 0x00, 0x00, //0x000001bd je LBB0_39
0x48, 0x8b, 0x4d, 0xb8, //0x000001c3 movq $-72(%rbp), %rcx
0x48, 0x01, 0xc1, //0x000001c7 addq %rax, %rcx
0x49, 0x01, 0xcb, //0x000001ca addq %rcx, %r11
0xf3, 0x0f, 0x6f, 0x15, 0x2b, 0xfe, 0xff, 0xff, //0x000001cd movdqu $-469(%rip), %xmm2 /* LCPI0_0+0(%rip) */
0xf3, 0x41, 0x0f, 0x6f, 0x27, //0x000001d5 movdqu (%r15), %xmm4
0x66, 0x0f, 0x6f, 0xdc, //0x000001da movdqa %xmm4, %xmm3
0x66, 0x0f, 0x64, 0xda, //0x000001de pcmpgtb %xmm2, %xmm3
0xf3, 0x0f, 0x6f, 0x0d, 0x26, 0xfe, 0xff, 0xff, //0x000001e2 movdqu $-474(%rip), %xmm1 /* LCPI0_1+0(%rip) */
0x66, 0x0f, 0x6f, 0xc1, //0x000001ea movdqa %xmm1, %xmm0
0x66, 0x0f, 0x64, 0xc4, //0x000001ee pcmpgtb %xmm4, %xmm0
0x66, 0x0f, 0xdb, 0xc3, //0x000001f2 pand %xmm3, %xmm0
0xf3, 0x0f, 0x6f, 0x1d, 0x22, 0xfe, 0xff, 0xff, //0x000001f6 movdqu $-478(%rip), %xmm3 /* LCPI0_2+0(%rip) */
0x66, 0x0f, 0xdb, 0xc3, //0x000001fe pand %xmm3, %xmm0
0x66, 0x0f, 0x71, 0xf0, 0x05, //0x00000202 psllw $5, %xmm0
0x66, 0x0f, 0xfc, 0xc4, //0x00000207 paddb %xmm4, %xmm0
0x41, 0x0f, 0xb6, 0xca, //0x0000020b movzbl %r10b, %ecx
0x41, 0x83, 0xf8, 0x09, //0x0000020f cmpl $9, %r8d
0x0f, 0x83, 0xed, 0x00, 0x00, 0x00, //0x00000213 jae LBB0_22
0xf3, 0x0f, 0x7f, 0x45, 0xc0, //0x00000219 movdqu %xmm0, $-64(%rbp)
0x8a, 0x55, 0xc0, //0x0000021e movb $-64(%rbp), %dl
0x8a, 0x5d, 0xc1, //0x00000221 movb $-63(%rbp), %bl
0x44, 0x8a, 0x65, 0xc2, //0x00000224 movb $-62(%rbp), %r12b
0x44, 0x8a, 0x6d, 0xc3, //0x00000228 movb $-61(%rbp), %r13b
0x44, 0x8a, 0x55, 0xc4, //0x0000022c movb $-60(%rbp), %r10b
0x44, 0x8a, 0x75, 0xc5, //0x00000230 movb $-59(%rbp), %r14b
0x44, 0x8a, 0x7d, 0xc6, //0x00000234 movb $-58(%rbp), %r15b
0x8a, 0x45, 0xc7, //0x00000238 movb $-57(%rbp), %al
0x41, 0x83, 0xc0, 0x01, //0x0000023b addl $1, %r8d
0x41, 0x83, 0xf9, 0x02, //0x0000023f cmpl $2, %r9d
0xbf, 0x01, 0x00, 0x00, 0x00, //0x00000243 movl $1, %edi
0x41, 0x0f, 0x43, 0xf9, //0x00000248 cmovael %r9d, %edi
0x90, 0x90, 0x90, 0x90, //0x0000024c .p2align 4, 0x90
//0x00000250 LBB0_26
0x41, 0x38, 0x13, //0x00000250 cmpb %dl, (%r11)
0x0f, 0x85, 0x77, 0x00, 0x00, 0x00, //0x00000253 jne LBB0_27
0xbe, 0x01, 0x00, 0x00, 0x00, //0x00000259 movl $1, %esi
0x41, 0x38, 0x5b, 0x01, //0x0000025e cmpb %bl, $1(%r11)
0x0f, 0x85, 0x6a, 0x00, 0x00, 0x00, //0x00000262 jne LBB0_35
0xbe, 0x02, 0x00, 0x00, 0x00, //0x00000268 movl $2, %esi
0x45, 0x38, 0x63, 0x02, //0x0000026d cmpb %r12b, $2(%r11)
0x0f, 0x85, 0x5b, 0x00, 0x00, 0x00, //0x00000271 jne LBB0_35
0xbe, 0x03, 0x00, 0x00, 0x00, //0x00000277 movl $3, %esi
0x45, 0x38, 0x6b, 0x03, //0x0000027c cmpb %r13b, $3(%r11)
0x0f, 0x85, 0x4c, 0x00, 0x00, 0x00, //0x00000280 jne LBB0_35
0xbe, 0x04, 0x00, 0x00, 0x00, //0x00000286 movl $4, %esi
0x45, 0x38, 0x53, 0x04, //0x0000028b cmpb %r10b, $4(%r11)
0x0f, 0x85, 0x3d, 0x00, 0x00, 0x00, //0x0000028f jne LBB0_35
0xbe, 0x05, 0x00, 0x00, 0x00, //0x00000295 movl $5, %esi
0x45, 0x38, 0x73, 0x05, //0x0000029a cmpb %r14b, $5(%r11)
0x0f, 0x85, 0x2e, 0x00, 0x00, 0x00, //0x0000029e jne LBB0_35
0xbe, 0x06, 0x00, 0x00, 0x00, //0x000002a4 movl $6, %esi
0x45, 0x38, 0x7b, 0x06, //0x000002a9 cmpb %r15b, $6(%r11)
0x0f, 0x85, 0x1f, 0x00, 0x00, 0x00, //0x000002ad jne LBB0_35
0x31, 0xf6, //0x000002b3 xorl %esi, %esi
0x41, 0x38, 0x43, 0x07, //0x000002b5 cmpb %al, $7(%r11)
0x40, 0x0f, 0x94, 0xc6, //0x000002b9 sete %sil
0x48, 0x83, 0xc6, 0x07, //0x000002bd addq $7, %rsi
0xe9, 0x0c, 0x00, 0x00, 0x00, //0x000002c1 jmp LBB0_35
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x000002c6 .p2align 4, 0x90
//0x000002d0 LBB0_27
0x31, 0xf6, //0x000002d0 xorl %esi, %esi
//0x000002d2 LBB0_35
0x48, 0x39, 0xce, //0x000002d2 cmpq %rcx, %rsi
0x0f, 0x83, 0xc2, 0x00, 0x00, 0x00, //0x000002d5 jae LBB0_36
0x4d, 0x01, 0xc3, //0x000002db addq %r8, %r11
0x83, 0xc7, 0xff, //0x000002de addl $-1, %edi
0x0f, 0x85, 0x69, 0xff, 0xff, 0xff, //0x000002e1 jne LBB0_26
0xe9, 0x9b, 0x00, 0x00, 0x00, //0x000002e7 jmp LBB0_39
//0x000002ec LBB0_17
0x4c, 0x01, 0xee, //0x000002ec addq %r13, %rsi
0x48, 0x83, 0xc6, 0xff, //0x000002ef addq $-1, %rsi
0x0f, 0xb6, 0x06, //0x000002f3 movzbl (%rsi), %eax
0xe9, 0x93, 0x00, 0x00, 0x00, //0x000002f6 jmp LBB0_40
//0x000002fb LBB0_4
0x48, 0x01, 0xce, //0x000002fb addq %rcx, %rsi
0x0f, 0xb6, 0x06, //0x000002fe movzbl (%rsi), %eax
0xe9, 0x88, 0x00, 0x00, 0x00, //0x00000301 jmp LBB0_40
//0x00000306 LBB0_22
0xf3, 0x41, 0x0f, 0x6f, 0x67, 0x10, //0x00000306 movdqu $16(%r15), %xmm4
0x66, 0x0f, 0x6f, 0xec, //0x0000030c movdqa %xmm4, %xmm5
0x66, 0x0f, 0x64, 0xea, //0x00000310 pcmpgtb %xmm2, %xmm5
0x66, 0x0f, 0x64, 0xcc, //0x00000314 pcmpgtb %xmm4, %xmm1
0x66, 0x0f, 0xdb, 0xcd, //0x00000318 pand %xmm5, %xmm1
0x66, 0x0f, 0xdb, 0xcb, //0x0000031c pand %xmm3, %xmm1
0x66, 0x0f, 0x71, 0xf1, 0x05, //0x00000320 psllw $5, %xmm1
0x66, 0x0f, 0xfc, 0xcc, //0x00000325 paddb %xmm4, %xmm1
0x48, 0xc7, 0xc0, 0xff, 0xff, 0xff, 0xff, //0x00000329 movq $-1, %rax
0x48, 0xd3, 0xe0, //0x00000330 shlq %cl, %rax
0x41, 0x83, 0xc0, 0x01, //0x00000333 addl $1, %r8d
0x41, 0x83, 0xf9, 0x02, //0x00000337 cmpl $2, %r9d
0xba, 0x01, 0x00, 0x00, 0x00, //0x0000033b movl $1, %edx
0x41, 0x0f, 0x43, 0xd1, //0x00000340 cmovael %r9d, %edx
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000344 .p2align 4, 0x90
//0x00000350 LBB0_23
0xf3, 0x41, 0x0f, 0x6f, 0x13, //0x00000350 movdqu (%r11), %xmm2
0xf3, 0x41, 0x0f, 0x6f, 0x5b, 0x10, //0x00000355 movdqu $16(%r11), %xmm3
0x66, 0x0f, 0x74, 0xd9, //0x0000035b pcmpeqb %xmm1, %xmm3
0x66, 0x0f, 0x74, 0xd0, //0x0000035f pcmpeqb %xmm0, %xmm2
0x66, 0x0f, 0xd7, 0xf2, //0x00000363 pmovmskb %xmm2, %esi
0x66, 0x0f, 0xd7, 0xfb, //0x00000367 pmovmskb %xmm3, %edi
0xc1, 0xe7, 0x10, //0x0000036b shll $16, %edi
0x09, 0xf7, //0x0000036e orl %esi, %edi
0x09, 0xc7, //0x00000370 orl %eax, %edi
0x83, 0xff, 0xff, //0x00000372 cmpl $-1, %edi
0x0f, 0x84, 0x32, 0x00, 0x00, 0x00, //0x00000375 je LBB0_24
0x4d, 0x01, 0xc3, //0x0000037b addq %r8, %r11
0x83, 0xc2, 0xff, //0x0000037e addl $-1, %edx
0x0f, 0x85, 0xc9, 0xff, 0xff, 0xff, //0x00000381 jne LBB0_23
//0x00000387 LBB0_39
0x48, 0xc7, 0xc0, 0xff, 0xff, 0xff, 0xff, //0x00000387 movq $-1, %rax
//0x0000038e LBB0_40
0x48, 0x83, 0xc4, 0x28, //0x0000038e addq $40, %rsp
0x5b, //0x00000392 popq %rbx
0x41, 0x5c, //0x00000393 popq %r12
0x41, 0x5d, //0x00000395 popq %r13
0x41, 0x5e, //0x00000397 popq %r14
0x41, 0x5f, //0x00000399 popq %r15
0x5d, //0x0000039b popq %rbp
0xc3, //0x0000039c retq
//0x0000039d LBB0_36
0x4b, 0x8d, 0x34, 0x18, //0x0000039d leaq (%r8,%r11), %rsi
0x48, 0x83, 0xc6, 0xff, //0x000003a1 addq $-1, %rsi
0x0f, 0xb6, 0x06, //0x000003a5 movzbl (%rsi), %eax
0xe9, 0xe1, 0xff, 0xff, 0xff, //0x000003a8 jmp LBB0_40
//0x000003ad LBB0_24
0x49, 0x01, 0xcb, //0x000003ad addq %rcx, %r11
0x4c, 0x89, 0xde, //0x000003b0 movq %r11, %rsi
0x41, 0x0f, 0xb6, 0x03, //0x000003b3 movzbl (%r11), %eax
0xe9, 0xd2, 0xff, 0xff, 0xff, //0x000003b7 jmp LBB0_40
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/vunsigned.go | vendor/github.com/bytedance/sonic/internal/native/sse/vunsigned.go | /*
* 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
import (
`unsafe`
`github.com/bytedance/sonic/internal/native/types`
`github.com/bytedance/sonic/internal/rt`
)
var F_vunsigned func(s unsafe.Pointer, p unsafe.Pointer, v unsafe.Pointer)
var S_vunsigned uintptr
//go:nosplit
func vunsigned(s *string, p *int, v *types.JsonState) {
F_vunsigned(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(v)))
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/skip_object_subr.go | vendor/github.com/bytedance/sonic/internal/native/sse/skip_object_subr.go | // +build !noasm !appengine
// Code generated by asm2asm, DO NOT EDIT.
package sse
import (
`github.com/bytedance/sonic/loader`
)
const (
_entry__skip_object = 256
)
const (
_stack__skip_object = 184
)
const (
_size__skip_object = 15328
)
var (
_pcsp__skip_object = [][2]uint32{
{0x1, 0},
{0x6, 8},
{0x8, 16},
{0xa, 24},
{0xc, 32},
{0xd, 40},
{0x14, 48},
{0x394e, 184},
{0x394f, 48},
{0x3951, 40},
{0x3953, 32},
{0x3955, 24},
{0x3957, 16},
{0x3958, 8},
{0x3959, 0},
{0x3be0, 184},
}
)
var _cfunc_skip_object = []loader.CFunc{
{"_skip_object_entry", 0, _entry__skip_object, 0, nil},
{"_skip_object", _entry__skip_object, _size__skip_object, _stack__skip_object, _pcsp__skip_object},
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/get_by_path.go | vendor/github.com/bytedance/sonic/internal/native/sse/get_by_path.go | // 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
import (
`unsafe`
`github.com/bytedance/sonic/internal/native/types`
`github.com/bytedance/sonic/internal/rt`
)
var F_get_by_path func(s unsafe.Pointer, p unsafe.Pointer, path unsafe.Pointer, m unsafe.Pointer) (ret int)
var S_get_by_path uintptr
//go:nosplit
func get_by_path(s *string, p *int, path *[]interface{}, m *types.StateMachine) (ret int) {
return F_get_by_path(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)), rt.NoEscape(unsafe.Pointer(path)), rt.NoEscape(unsafe.Pointer(m)))
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/vstring_subr.go | vendor/github.com/bytedance/sonic/internal/native/sse/vstring_subr.go | // +build !noasm !appengine
// Code generated by asm2asm, DO NOT EDIT.
package sse
import (
`github.com/bytedance/sonic/loader`
)
const (
_entry__vstring = 48
)
const (
_stack__vstring = 104
)
const (
_size__vstring = 2396
)
var (
_pcsp__vstring = [][2]uint32{
{0x1, 0},
{0x6, 8},
{0x8, 16},
{0xa, 24},
{0xc, 32},
{0xd, 40},
{0x11, 48},
{0x8b1, 104},
{0x8b2, 48},
{0x8b4, 40},
{0x8b6, 32},
{0x8b8, 24},
{0x8ba, 16},
{0x8bb, 8},
{0x8bc, 0},
{0x95c, 104},
}
)
var _cfunc_vstring = []loader.CFunc{
{"_vstring_entry", 0, _entry__vstring, 0, nil},
{"_vstring", _entry__vstring, _size__vstring, _stack__vstring, _pcsp__vstring},
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/skip_number_text_amd64.go | vendor/github.com/bytedance/sonic/internal/native/sse/skip_number_text_amd64.go | // +build amd64
// Code generated by asm2asm, DO NOT EDIT.
package sse
var _text_skip_number = []byte{
// .p2align 4, 0x00
// LCPI0_0
0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, // QUAD $0x2f2f2f2f2f2f2f2f; QUAD $0x2f2f2f2f2f2f2f2f // .space 16, '////////////////'
//0x00000010 LCPI0_1
0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, //0x00000010 QUAD $0x3a3a3a3a3a3a3a3a; QUAD $0x3a3a3a3a3a3a3a3a // .space 16, '::::::::::::::::'
//0x00000020 LCPI0_2
0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, //0x00000020 QUAD $0x2b2b2b2b2b2b2b2b; QUAD $0x2b2b2b2b2b2b2b2b // .space 16, '++++++++++++++++'
//0x00000030 LCPI0_3
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, //0x00000030 QUAD $0x2d2d2d2d2d2d2d2d; QUAD $0x2d2d2d2d2d2d2d2d // .space 16, '----------------'
//0x00000040 LCPI0_4
0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, //0x00000040 QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf'
//0x00000050 LCPI0_5
0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, //0x00000050 QUAD $0x2e2e2e2e2e2e2e2e; QUAD $0x2e2e2e2e2e2e2e2e // .space 16, '................'
//0x00000060 LCPI0_6
0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, //0x00000060 QUAD $0x4545454545454545; QUAD $0x4545454545454545 // .space 16, 'EEEEEEEEEEEEEEEE'
//0x00000070 .p2align 4, 0x90
//0x00000070 _skip_number
0x55, //0x00000070 pushq %rbp
0x48, 0x89, 0xe5, //0x00000071 movq %rsp, %rbp
0x41, 0x57, //0x00000074 pushq %r15
0x41, 0x56, //0x00000076 pushq %r14
0x41, 0x55, //0x00000078 pushq %r13
0x41, 0x54, //0x0000007a pushq %r12
0x53, //0x0000007c pushq %rbx
0x48, 0x83, 0xec, 0x18, //0x0000007d subq $24, %rsp
0x48, 0x8b, 0x17, //0x00000081 movq (%rdi), %rdx
0x4c, 0x8b, 0x6f, 0x08, //0x00000084 movq $8(%rdi), %r13
0x4c, 0x8b, 0x0e, //0x00000088 movq (%rsi), %r9
0x4d, 0x29, 0xcd, //0x0000008b subq %r9, %r13
0x45, 0x31, 0xff, //0x0000008e xorl %r15d, %r15d
0x42, 0x80, 0x3c, 0x0a, 0x2d, //0x00000091 cmpb $45, (%rdx,%r9)
0x4a, 0x8d, 0x1c, 0x0a, //0x00000096 leaq (%rdx,%r9), %rbx
0x41, 0x0f, 0x94, 0xc7, //0x0000009a sete %r15b
0x4e, 0x8d, 0x1c, 0x3b, //0x0000009e leaq (%rbx,%r15), %r11
0x4d, 0x29, 0xfd, //0x000000a2 subq %r15, %r13
0x0f, 0x84, 0xbb, 0x03, 0x00, 0x00, //0x000000a5 je LBB0_1
0x41, 0x8a, 0x3b, //0x000000ab movb (%r11), %dil
0x8d, 0x4f, 0xd0, //0x000000ae leal $-48(%rdi), %ecx
0x48, 0xc7, 0xc0, 0xfe, 0xff, 0xff, 0xff, //0x000000b1 movq $-2, %rax
0x80, 0xf9, 0x09, //0x000000b8 cmpb $9, %cl
0x0f, 0x87, 0x18, 0x03, 0x00, 0x00, //0x000000bb ja LBB0_59
0x48, 0x89, 0x55, 0xc8, //0x000000c1 movq %rdx, $-56(%rbp)
0x48, 0x89, 0x75, 0xc0, //0x000000c5 movq %rsi, $-64(%rbp)
0x40, 0x80, 0xff, 0x30, //0x000000c9 cmpb $48, %dil
0x0f, 0x85, 0x34, 0x00, 0x00, 0x00, //0x000000cd jne LBB0_7
0xba, 0x01, 0x00, 0x00, 0x00, //0x000000d3 movl $1, %edx
0x49, 0x83, 0xfd, 0x01, //0x000000d8 cmpq $1, %r13
0x0f, 0x84, 0xcf, 0x02, 0x00, 0x00, //0x000000dc je LBB0_58
0x41, 0x8a, 0x43, 0x01, //0x000000e2 movb $1(%r11), %al
0x04, 0xd2, //0x000000e6 addb $-46, %al
0x3c, 0x37, //0x000000e8 cmpb $55, %al
0x0f, 0x87, 0xc1, 0x02, 0x00, 0x00, //0x000000ea ja LBB0_58
0x0f, 0xb6, 0xc0, //0x000000f0 movzbl %al, %eax
0x48, 0xb9, 0x01, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, //0x000000f3 movabsq $36028797027352577, %rcx
0x48, 0x0f, 0xa3, 0xc1, //0x000000fd btq %rax, %rcx
0x0f, 0x83, 0xaa, 0x02, 0x00, 0x00, //0x00000101 jae LBB0_58
//0x00000107 LBB0_7
0x48, 0x89, 0x5d, 0xd0, //0x00000107 movq %rbx, $-48(%rbp)
0x49, 0x83, 0xfd, 0x10, //0x0000010b cmpq $16, %r13
0x0f, 0x82, 0x5d, 0x03, 0x00, 0x00, //0x0000010f jb LBB0_8
0x49, 0xc7, 0xc0, 0xff, 0xff, 0xff, 0xff, //0x00000115 movq $-1, %r8
0x31, 0xd2, //0x0000011c xorl %edx, %edx
0xf3, 0x44, 0x0f, 0x6f, 0x05, 0xd9, 0xfe, 0xff, 0xff, //0x0000011e movdqu $-295(%rip), %xmm8 /* LCPI0_0+0(%rip) */
0xf3, 0x44, 0x0f, 0x6f, 0x15, 0xe0, 0xfe, 0xff, 0xff, //0x00000127 movdqu $-288(%rip), %xmm10 /* LCPI0_1+0(%rip) */
0xf3, 0x44, 0x0f, 0x6f, 0x0d, 0xe7, 0xfe, 0xff, 0xff, //0x00000130 movdqu $-281(%rip), %xmm9 /* LCPI0_2+0(%rip) */
0xf3, 0x0f, 0x6f, 0x1d, 0xef, 0xfe, 0xff, 0xff, //0x00000139 movdqu $-273(%rip), %xmm3 /* LCPI0_3+0(%rip) */
0xf3, 0x0f, 0x6f, 0x25, 0xf7, 0xfe, 0xff, 0xff, //0x00000141 movdqu $-265(%rip), %xmm4 /* LCPI0_4+0(%rip) */
0xf3, 0x0f, 0x6f, 0x2d, 0xff, 0xfe, 0xff, 0xff, //0x00000149 movdqu $-257(%rip), %xmm5 /* LCPI0_5+0(%rip) */
0xf3, 0x0f, 0x6f, 0x35, 0x07, 0xff, 0xff, 0xff, //0x00000151 movdqu $-249(%rip), %xmm6 /* LCPI0_6+0(%rip) */
0x49, 0xc7, 0xc4, 0xff, 0xff, 0xff, 0xff, //0x00000159 movq $-1, %r12
0x49, 0xc7, 0xc6, 0xff, 0xff, 0xff, 0xff, //0x00000160 movq $-1, %r14
0x4c, 0x89, 0xef, //0x00000167 movq %r13, %rdi
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x0000016a .p2align 4, 0x90
//0x00000170 LBB0_10
0xf3, 0x41, 0x0f, 0x6f, 0x3c, 0x13, //0x00000170 movdqu (%r11,%rdx), %xmm7
0x66, 0x0f, 0x6f, 0xc7, //0x00000176 movdqa %xmm7, %xmm0
0x66, 0x41, 0x0f, 0x64, 0xc0, //0x0000017a pcmpgtb %xmm8, %xmm0
0x66, 0x41, 0x0f, 0x6f, 0xca, //0x0000017f movdqa %xmm10, %xmm1
0x66, 0x0f, 0x64, 0xcf, //0x00000184 pcmpgtb %xmm7, %xmm1
0x66, 0x0f, 0xdb, 0xc8, //0x00000188 pand %xmm0, %xmm1
0x66, 0x0f, 0x6f, 0xc7, //0x0000018c movdqa %xmm7, %xmm0
0x66, 0x41, 0x0f, 0x74, 0xc1, //0x00000190 pcmpeqb %xmm9, %xmm0
0x66, 0x0f, 0x6f, 0xd7, //0x00000195 movdqa %xmm7, %xmm2
0x66, 0x0f, 0x74, 0xd3, //0x00000199 pcmpeqb %xmm3, %xmm2
0x66, 0x0f, 0xeb, 0xd0, //0x0000019d por %xmm0, %xmm2
0x66, 0x0f, 0x6f, 0xc7, //0x000001a1 movdqa %xmm7, %xmm0
0x66, 0x0f, 0xdb, 0xc4, //0x000001a5 pand %xmm4, %xmm0
0x66, 0x0f, 0x74, 0xc6, //0x000001a9 pcmpeqb %xmm6, %xmm0
0x66, 0x0f, 0x74, 0xfd, //0x000001ad pcmpeqb %xmm5, %xmm7
0x66, 0x0f, 0xd7, 0xf0, //0x000001b1 pmovmskb %xmm0, %esi
0x66, 0x0f, 0xeb, 0xc7, //0x000001b5 por %xmm7, %xmm0
0x66, 0x0f, 0xeb, 0xca, //0x000001b9 por %xmm2, %xmm1
0x66, 0x0f, 0xeb, 0xc8, //0x000001bd por %xmm0, %xmm1
0x66, 0x0f, 0xd7, 0xdf, //0x000001c1 pmovmskb %xmm7, %ebx
0x66, 0x44, 0x0f, 0xd7, 0xd2, //0x000001c5 pmovmskb %xmm2, %r10d
0x66, 0x0f, 0xd7, 0xc1, //0x000001ca pmovmskb %xmm1, %eax
0xf7, 0xd0, //0x000001ce notl %eax
0x0f, 0xbc, 0xc8, //0x000001d0 bsfl %eax, %ecx
0x83, 0xf9, 0x10, //0x000001d3 cmpl $16, %ecx
0x0f, 0x84, 0x13, 0x00, 0x00, 0x00, //0x000001d6 je LBB0_12
0xb8, 0xff, 0xff, 0xff, 0xff, //0x000001dc movl $-1, %eax
0xd3, 0xe0, //0x000001e1 shll %cl, %eax
0xf7, 0xd0, //0x000001e3 notl %eax
0x21, 0xc3, //0x000001e5 andl %eax, %ebx
0x21, 0xc6, //0x000001e7 andl %eax, %esi
0x44, 0x21, 0xd0, //0x000001e9 andl %r10d, %eax
0x41, 0x89, 0xc2, //0x000001ec movl %eax, %r10d
//0x000001ef LBB0_12
0x8d, 0x43, 0xff, //0x000001ef leal $-1(%rbx), %eax
0x21, 0xd8, //0x000001f2 andl %ebx, %eax
0x0f, 0x85, 0x34, 0x02, 0x00, 0x00, //0x000001f4 jne LBB0_13
0x8d, 0x46, 0xff, //0x000001fa leal $-1(%rsi), %eax
0x21, 0xf0, //0x000001fd andl %esi, %eax
0x0f, 0x85, 0x29, 0x02, 0x00, 0x00, //0x000001ff jne LBB0_13
0x41, 0x8d, 0x42, 0xff, //0x00000205 leal $-1(%r10), %eax
0x44, 0x21, 0xd0, //0x00000209 andl %r10d, %eax
0x0f, 0x85, 0x1c, 0x02, 0x00, 0x00, //0x0000020c jne LBB0_13
0x85, 0xdb, //0x00000212 testl %ebx, %ebx
0x0f, 0x84, 0x13, 0x00, 0x00, 0x00, //0x00000214 je LBB0_20
0x0f, 0xbc, 0xdb, //0x0000021a bsfl %ebx, %ebx
0x49, 0x83, 0xfe, 0xff, //0x0000021d cmpq $-1, %r14
0x0f, 0x85, 0x2a, 0x02, 0x00, 0x00, //0x00000221 jne LBB0_60
0x48, 0x01, 0xd3, //0x00000227 addq %rdx, %rbx
0x49, 0x89, 0xde, //0x0000022a movq %rbx, %r14
//0x0000022d LBB0_20
0x85, 0xf6, //0x0000022d testl %esi, %esi
0x0f, 0x84, 0x13, 0x00, 0x00, 0x00, //0x0000022f je LBB0_23
0x0f, 0xbc, 0xf6, //0x00000235 bsfl %esi, %esi
0x49, 0x83, 0xfc, 0xff, //0x00000238 cmpq $-1, %r12
0x0f, 0x85, 0x16, 0x02, 0x00, 0x00, //0x0000023c jne LBB0_61
0x48, 0x01, 0xd6, //0x00000242 addq %rdx, %rsi
0x49, 0x89, 0xf4, //0x00000245 movq %rsi, %r12
//0x00000248 LBB0_23
0x45, 0x85, 0xd2, //0x00000248 testl %r10d, %r10d
0x0f, 0x84, 0x14, 0x00, 0x00, 0x00, //0x0000024b je LBB0_26
0x41, 0x0f, 0xbc, 0xc2, //0x00000251 bsfl %r10d, %eax
0x49, 0x83, 0xf8, 0xff, //0x00000255 cmpq $-1, %r8
0x0f, 0x85, 0x00, 0x02, 0x00, 0x00, //0x00000259 jne LBB0_62
0x48, 0x01, 0xd0, //0x0000025f addq %rdx, %rax
0x49, 0x89, 0xc0, //0x00000262 movq %rax, %r8
//0x00000265 LBB0_26
0x83, 0xf9, 0x10, //0x00000265 cmpl $16, %ecx
0x0f, 0x85, 0xab, 0x00, 0x00, 0x00, //0x00000268 jne LBB0_63
0x48, 0x83, 0xc7, 0xf0, //0x0000026e addq $-16, %rdi
0x48, 0x83, 0xc2, 0x10, //0x00000272 addq $16, %rdx
0x48, 0x83, 0xff, 0x0f, //0x00000276 cmpq $15, %rdi
0x0f, 0x87, 0xf0, 0xfe, 0xff, 0xff, //0x0000027a ja LBB0_10
0x49, 0x8d, 0x0c, 0x13, //0x00000280 leaq (%r11,%rdx), %rcx
0x49, 0x89, 0xca, //0x00000284 movq %rcx, %r10
0x49, 0x39, 0xd5, //0x00000287 cmpq %rdx, %r13
0x0f, 0x84, 0x92, 0x00, 0x00, 0x00, //0x0000028a je LBB0_42
//0x00000290 LBB0_29
0x4c, 0x8d, 0x14, 0x39, //0x00000290 leaq (%rcx,%rdi), %r10
0x48, 0x89, 0xc8, //0x00000294 movq %rcx, %rax
0x4c, 0x29, 0xd8, //0x00000297 subq %r11, %rax
0x31, 0xd2, //0x0000029a xorl %edx, %edx
0x4c, 0x8d, 0x2d, 0xf1, 0x01, 0x00, 0x00, //0x0000029c leaq $497(%rip), %r13 /* LJTI0_0+0(%rip) */
0xe9, 0x25, 0x00, 0x00, 0x00, //0x000002a3 jmp LBB0_30
//0x000002a8 LBB0_32
0x83, 0xfb, 0x65, //0x000002a8 cmpl $101, %ebx
0x0f, 0x85, 0x86, 0x00, 0x00, 0x00, //0x000002ab jne LBB0_41
//0x000002b1 LBB0_33
0x49, 0x83, 0xfc, 0xff, //0x000002b1 cmpq $-1, %r12
0x0f, 0x85, 0x81, 0x01, 0x00, 0x00, //0x000002b5 jne LBB0_64
0x4c, 0x8d, 0x24, 0x10, //0x000002bb leaq (%rax,%rdx), %r12
0x90, //0x000002bf .p2align 4, 0x90
//0x000002c0 LBB0_40
0x48, 0x83, 0xc2, 0x01, //0x000002c0 addq $1, %rdx
0x48, 0x39, 0xd7, //0x000002c4 cmpq %rdx, %rdi
0x0f, 0x84, 0x55, 0x00, 0x00, 0x00, //0x000002c7 je LBB0_42
//0x000002cd LBB0_30
0x0f, 0xbe, 0x1c, 0x11, //0x000002cd movsbl (%rcx,%rdx), %ebx
0x8d, 0x73, 0xd0, //0x000002d1 leal $-48(%rbx), %esi
0x83, 0xfe, 0x0a, //0x000002d4 cmpl $10, %esi
0x0f, 0x82, 0xe3, 0xff, 0xff, 0xff, //0x000002d7 jb LBB0_40
0x8d, 0x73, 0xd5, //0x000002dd leal $-43(%rbx), %esi
0x83, 0xfe, 0x1a, //0x000002e0 cmpl $26, %esi
0x0f, 0x87, 0xbf, 0xff, 0xff, 0xff, //0x000002e3 ja LBB0_32
0x49, 0x63, 0x74, 0xb5, 0x00, //0x000002e9 movslq (%r13,%rsi,4), %rsi
0x4c, 0x01, 0xee, //0x000002ee addq %r13, %rsi
0xff, 0xe6, //0x000002f1 jmpq *%rsi
//0x000002f3 LBB0_38
0x49, 0x83, 0xf8, 0xff, //0x000002f3 cmpq $-1, %r8
0x0f, 0x85, 0x3f, 0x01, 0x00, 0x00, //0x000002f7 jne LBB0_64
0x4c, 0x8d, 0x04, 0x10, //0x000002fd leaq (%rax,%rdx), %r8
0xe9, 0xba, 0xff, 0xff, 0xff, //0x00000301 jmp LBB0_40
//0x00000306 LBB0_36
0x49, 0x83, 0xfe, 0xff, //0x00000306 cmpq $-1, %r14
0x0f, 0x85, 0x2c, 0x01, 0x00, 0x00, //0x0000030a jne LBB0_64
0x4c, 0x8d, 0x34, 0x10, //0x00000310 leaq (%rax,%rdx), %r14
0xe9, 0xa7, 0xff, 0xff, 0xff, //0x00000314 jmp LBB0_40
//0x00000319 LBB0_63
0x41, 0x89, 0xca, //0x00000319 movl %ecx, %r10d
0x4d, 0x01, 0xda, //0x0000031c addq %r11, %r10
0x49, 0x01, 0xd2, //0x0000031f addq %rdx, %r10
//0x00000322 LBB0_42
0x48, 0xc7, 0xc2, 0xff, 0xff, 0xff, 0xff, //0x00000322 movq $-1, %rdx
0x4d, 0x85, 0xf6, //0x00000329 testq %r14, %r14
0x0f, 0x85, 0x1b, 0x00, 0x00, 0x00, //0x0000032c jne LBB0_43
0xe9, 0x8d, 0x00, 0x00, 0x00, //0x00000332 jmp LBB0_57
//0x00000337 LBB0_41
0x48, 0x01, 0xd1, //0x00000337 addq %rdx, %rcx
0x49, 0x89, 0xca, //0x0000033a movq %rcx, %r10
0x48, 0xc7, 0xc2, 0xff, 0xff, 0xff, 0xff, //0x0000033d movq $-1, %rdx
0x4d, 0x85, 0xf6, //0x00000344 testq %r14, %r14
0x0f, 0x84, 0x77, 0x00, 0x00, 0x00, //0x00000347 je LBB0_57
//0x0000034d LBB0_43
0x4d, 0x85, 0xc0, //0x0000034d testq %r8, %r8
0x0f, 0x84, 0x6e, 0x00, 0x00, 0x00, //0x00000350 je LBB0_57
0x4d, 0x85, 0xe4, //0x00000356 testq %r12, %r12
0x0f, 0x84, 0x65, 0x00, 0x00, 0x00, //0x00000359 je LBB0_57
0x4d, 0x29, 0xda, //0x0000035f subq %r11, %r10
0x49, 0x8d, 0x42, 0xff, //0x00000362 leaq $-1(%r10), %rax
0x49, 0x39, 0xc6, //0x00000366 cmpq %rax, %r14
0x0f, 0x84, 0x33, 0x00, 0x00, 0x00, //0x00000369 je LBB0_48
0x49, 0x39, 0xc0, //0x0000036f cmpq %rax, %r8
0x0f, 0x84, 0x2a, 0x00, 0x00, 0x00, //0x00000372 je LBB0_48
0x49, 0x39, 0xc4, //0x00000378 cmpq %rax, %r12
0x0f, 0x84, 0x21, 0x00, 0x00, 0x00, //0x0000037b je LBB0_48
0x4d, 0x85, 0xc0, //0x00000381 testq %r8, %r8
0x0f, 0x8e, 0x64, 0x00, 0x00, 0x00, //0x00000384 jle LBB0_52
0x49, 0x8d, 0x40, 0xff, //0x0000038a leaq $-1(%r8), %rax
0x49, 0x39, 0xc4, //0x0000038e cmpq %rax, %r12
0x0f, 0x84, 0x57, 0x00, 0x00, 0x00, //0x00000391 je LBB0_52
0x49, 0xf7, 0xd0, //0x00000397 notq %r8
0x4c, 0x89, 0xc2, //0x0000039a movq %r8, %rdx
0xe9, 0x06, 0x00, 0x00, 0x00, //0x0000039d jmp LBB0_56
//0x000003a2 LBB0_48
0x49, 0xf7, 0xda, //0x000003a2 negq %r10
0x4c, 0x89, 0xd2, //0x000003a5 movq %r10, %rdx
//0x000003a8 LBB0_56
0x48, 0x85, 0xd2, //0x000003a8 testq %rdx, %rdx
0x0f, 0x88, 0x13, 0x00, 0x00, 0x00, //0x000003ab js LBB0_57
//0x000003b1 LBB0_58
0x49, 0x01, 0xd3, //0x000003b1 addq %rdx, %r11
0x4c, 0x89, 0xc8, //0x000003b4 movq %r9, %rax
0x48, 0x8b, 0x75, 0xc0, //0x000003b7 movq $-64(%rbp), %rsi
0x48, 0x8b, 0x55, 0xc8, //0x000003bb movq $-56(%rbp), %rdx
0xe9, 0x15, 0x00, 0x00, 0x00, //0x000003bf jmp LBB0_59
//0x000003c4 LBB0_57
0x48, 0xf7, 0xd2, //0x000003c4 notq %rdx
0x49, 0x01, 0xd3, //0x000003c7 addq %rdx, %r11
0x48, 0x8b, 0x75, 0xc0, //0x000003ca movq $-64(%rbp), %rsi
0x48, 0x8b, 0x55, 0xc8, //0x000003ce movq $-56(%rbp), %rdx
0x48, 0xc7, 0xc0, 0xfe, 0xff, 0xff, 0xff, //0x000003d2 movq $-2, %rax
//0x000003d9 LBB0_59
0x49, 0x29, 0xd3, //0x000003d9 subq %rdx, %r11
0x4c, 0x89, 0x1e, //0x000003dc movq %r11, (%rsi)
0x48, 0x83, 0xc4, 0x18, //0x000003df addq $24, %rsp
0x5b, //0x000003e3 popq %rbx
0x41, 0x5c, //0x000003e4 popq %r12
0x41, 0x5d, //0x000003e6 popq %r13
0x41, 0x5e, //0x000003e8 popq %r14
0x41, 0x5f, //0x000003ea popq %r15
0x5d, //0x000003ec popq %rbp
0xc3, //0x000003ed retq
//0x000003ee LBB0_52
0x4c, 0x89, 0xf0, //0x000003ee movq %r14, %rax
0x4c, 0x09, 0xe0, //0x000003f1 orq %r12, %rax
0x0f, 0x99, 0xc0, //0x000003f4 setns %al
0x0f, 0x88, 0x14, 0x00, 0x00, 0x00, //0x000003f7 js LBB0_55
0x4d, 0x39, 0xe6, //0x000003fd cmpq %r12, %r14
0x0f, 0x8c, 0x0b, 0x00, 0x00, 0x00, //0x00000400 jl LBB0_55
0x49, 0xf7, 0xd6, //0x00000406 notq %r14
0x4c, 0x89, 0xf2, //0x00000409 movq %r14, %rdx
0xe9, 0x97, 0xff, 0xff, 0xff, //0x0000040c jmp LBB0_56
//0x00000411 LBB0_55
0x49, 0x8d, 0x4c, 0x24, 0xff, //0x00000411 leaq $-1(%r12), %rcx
0x49, 0x39, 0xce, //0x00000416 cmpq %rcx, %r14
0x49, 0xf7, 0xd4, //0x00000419 notq %r12
0x4d, 0x0f, 0x45, 0xe2, //0x0000041c cmovneq %r10, %r12
0x84, 0xc0, //0x00000420 testb %al, %al
0x4d, 0x0f, 0x44, 0xe2, //0x00000422 cmoveq %r10, %r12
0x4c, 0x89, 0xe2, //0x00000426 movq %r12, %rdx
0xe9, 0x7a, 0xff, 0xff, 0xff, //0x00000429 jmp LBB0_56
//0x0000042e LBB0_13
0x0f, 0xbc, 0xc0, //0x0000042e bsfl %eax, %eax
//0x00000431 LBB0_14
0x48, 0xf7, 0xd2, //0x00000431 notq %rdx
0x48, 0x29, 0xc2, //0x00000434 subq %rax, %rdx
0xe9, 0x6c, 0xff, 0xff, 0xff, //0x00000437 jmp LBB0_56
//0x0000043c LBB0_64
0x48, 0x8b, 0x45, 0xd0, //0x0000043c movq $-48(%rbp), %rax
0x4c, 0x01, 0xf8, //0x00000440 addq %r15, %rax
0x48, 0x29, 0xc8, //0x00000443 subq %rcx, %rax
0x48, 0xf7, 0xd2, //0x00000446 notq %rdx
0x48, 0x01, 0xc2, //0x00000449 addq %rax, %rdx
0xe9, 0x57, 0xff, 0xff, 0xff, //0x0000044c jmp LBB0_56
//0x00000451 LBB0_60
0x89, 0xd8, //0x00000451 movl %ebx, %eax
0xe9, 0xd9, 0xff, 0xff, 0xff, //0x00000453 jmp LBB0_14
//0x00000458 LBB0_61
0x89, 0xf0, //0x00000458 movl %esi, %eax
0xe9, 0xd2, 0xff, 0xff, 0xff, //0x0000045a jmp LBB0_14
//0x0000045f LBB0_62
0x89, 0xc0, //0x0000045f movl %eax, %eax
0xe9, 0xcb, 0xff, 0xff, 0xff, //0x00000461 jmp LBB0_14
//0x00000466 LBB0_1
0x48, 0xc7, 0xc0, 0xff, 0xff, 0xff, 0xff, //0x00000466 movq $-1, %rax
0xe9, 0x67, 0xff, 0xff, 0xff, //0x0000046d jmp LBB0_59
//0x00000472 LBB0_8
0x49, 0xc7, 0xc6, 0xff, 0xff, 0xff, 0xff, //0x00000472 movq $-1, %r14
0x4c, 0x89, 0xd9, //0x00000479 movq %r11, %rcx
0x4c, 0x89, 0xef, //0x0000047c movq %r13, %rdi
0x49, 0xc7, 0xc4, 0xff, 0xff, 0xff, 0xff, //0x0000047f movq $-1, %r12
0x49, 0xc7, 0xc0, 0xff, 0xff, 0xff, 0xff, //0x00000486 movq $-1, %r8
0xe9, 0xfe, 0xfd, 0xff, 0xff, //0x0000048d jmp LBB0_29
0x90, 0x90, //0x00000492 .p2align 2, 0x90
// // .set L0_0_set_38, LBB0_38-LJTI0_0
// // .set L0_0_set_41, LBB0_41-LJTI0_0
// // .set L0_0_set_36, LBB0_36-LJTI0_0
// // .set L0_0_set_33, LBB0_33-LJTI0_0
//0x00000494 LJTI0_0
0x5f, 0xfe, 0xff, 0xff, //0x00000494 .long L0_0_set_38
0xa3, 0xfe, 0xff, 0xff, //0x00000498 .long L0_0_set_41
0x5f, 0xfe, 0xff, 0xff, //0x0000049c .long L0_0_set_38
0x72, 0xfe, 0xff, 0xff, //0x000004a0 .long L0_0_set_36
0xa3, 0xfe, 0xff, 0xff, //0x000004a4 .long L0_0_set_41
0xa3, 0xfe, 0xff, 0xff, //0x000004a8 .long L0_0_set_41
0xa3, 0xfe, 0xff, 0xff, //0x000004ac .long L0_0_set_41
0xa3, 0xfe, 0xff, 0xff, //0x000004b0 .long L0_0_set_41
0xa3, 0xfe, 0xff, 0xff, //0x000004b4 .long L0_0_set_41
0xa3, 0xfe, 0xff, 0xff, //0x000004b8 .long L0_0_set_41
0xa3, 0xfe, 0xff, 0xff, //0x000004bc .long L0_0_set_41
0xa3, 0xfe, 0xff, 0xff, //0x000004c0 .long L0_0_set_41
0xa3, 0xfe, 0xff, 0xff, //0x000004c4 .long L0_0_set_41
0xa3, 0xfe, 0xff, 0xff, //0x000004c8 .long L0_0_set_41
0xa3, 0xfe, 0xff, 0xff, //0x000004cc .long L0_0_set_41
0xa3, 0xfe, 0xff, 0xff, //0x000004d0 .long L0_0_set_41
0xa3, 0xfe, 0xff, 0xff, //0x000004d4 .long L0_0_set_41
0xa3, 0xfe, 0xff, 0xff, //0x000004d8 .long L0_0_set_41
0xa3, 0xfe, 0xff, 0xff, //0x000004dc .long L0_0_set_41
0xa3, 0xfe, 0xff, 0xff, //0x000004e0 .long L0_0_set_41
0xa3, 0xfe, 0xff, 0xff, //0x000004e4 .long L0_0_set_41
0xa3, 0xfe, 0xff, 0xff, //0x000004e8 .long L0_0_set_41
0xa3, 0xfe, 0xff, 0xff, //0x000004ec .long L0_0_set_41
0xa3, 0xfe, 0xff, 0xff, //0x000004f0 .long L0_0_set_41
0xa3, 0xfe, 0xff, 0xff, //0x000004f4 .long L0_0_set_41
0xa3, 0xfe, 0xff, 0xff, //0x000004f8 .long L0_0_set_41
0x1d, 0xfe, 0xff, 0xff, //0x000004fc .long L0_0_set_33
//0x00000500 .p2align 2, 0x00
//0x00000500 _MASK_USE_NUMBER
0x02, 0x00, 0x00, 0x00, //0x00000500 .long 2
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/skip_number.go | vendor/github.com/bytedance/sonic/internal/native/sse/skip_number.go | // 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
import (
`unsafe`
`github.com/bytedance/sonic/internal/rt`
)
var F_skip_number func(s unsafe.Pointer, p unsafe.Pointer) (ret int)
var S_skip_number uintptr
//go:nosplit
func skip_number(s *string, p *int) (ret int) {
return F_skip_number(rt.NoEscape(unsafe.Pointer(s)), rt.NoEscape(unsafe.Pointer(p)))
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/quote_subr.go | vendor/github.com/bytedance/sonic/internal/native/sse/quote_subr.go | // +build !noasm !appengine
// Code generated by asm2asm, DO NOT EDIT.
package sse
import (
`github.com/bytedance/sonic/loader`
)
const (
_entry__quote = 48
)
const (
_stack__quote = 80
)
const (
_size__quote = 1760
)
var (
_pcsp__quote = [][2]uint32{
{0x1, 0},
{0x6, 8},
{0x8, 16},
{0xa, 24},
{0xc, 32},
{0xd, 40},
{0x11, 48},
{0x6a9, 80},
{0x6aa, 48},
{0x6ac, 40},
{0x6ae, 32},
{0x6b0, 24},
{0x6b2, 16},
{0x6b3, 8},
{0x6b4, 0},
{0x6e0, 80},
}
)
var _cfunc_quote = []loader.CFunc{
{"_quote_entry", 0, _entry__quote, 0, nil},
{"_quote", _entry__quote, _size__quote, _stack__quote, _pcsp__quote},
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/f64toa_subr.go | vendor/github.com/bytedance/sonic/internal/native/sse/f64toa_subr.go | // +build !noasm !appengine
// Code generated by asm2asm, DO NOT EDIT.
package sse
import (
`github.com/bytedance/sonic/loader`
)
const (
_entry__f64toa = 16
)
const (
_stack__f64toa = 72
)
const (
_size__f64toa = 4992
)
var (
_pcsp__f64toa = [][2]uint32{
{0x1, 0},
{0x6, 8},
{0x8, 16},
{0xa, 24},
{0xc, 32},
{0xd, 40},
{0x11, 48},
{0x131d, 72},
{0x131e, 48},
{0x1320, 40},
{0x1322, 32},
{0x1324, 24},
{0x1326, 16},
{0x1327, 8},
{0x1328, 0},
{0x1380, 72},
}
)
var _cfunc_f64toa = []loader.CFunc{
{"_f64toa_entry", 0, _entry__f64toa, 0, nil},
{"_f64toa", _entry__f64toa, _size__f64toa, _stack__f64toa, _pcsp__f64toa},
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/validate_utf8_subr.go | vendor/github.com/bytedance/sonic/internal/native/sse/validate_utf8_subr.go | // +build !noasm !appengine
// Code generated by asm2asm, DO NOT EDIT.
package sse
import (
`github.com/bytedance/sonic/loader`
)
const (
_entry__validate_utf8 = 0
)
const (
_stack__validate_utf8 = 48
)
const (
_size__validate_utf8 = 684
)
var (
_pcsp__validate_utf8 = [][2]uint32{
{0x1, 0},
{0x6, 8},
{0x8, 16},
{0xa, 24},
{0xb, 32},
{0xc, 40},
{0x283, 48},
{0x284, 40},
{0x286, 32},
{0x288, 24},
{0x28a, 16},
{0x28b, 8},
{0x28c, 0},
{0x2ac, 48},
}
)
var _cfunc_validate_utf8 = []loader.CFunc{
{"_validate_utf8_entry", 0, _entry__validate_utf8, 0, nil},
{"_validate_utf8", _entry__validate_utf8, _size__validate_utf8, _stack__validate_utf8, _pcsp__validate_utf8},
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/skip_one_text_amd64.go | vendor/github.com/bytedance/sonic/internal/native/sse/skip_one_text_amd64.go | // +build amd64
// Code generated by asm2asm, DO NOT EDIT.
package sse
var _text_skip_one = []byte{
// .p2align 4, 0x00
// LCPI0_0
0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, // QUAD $0x2c2c2c2c2c2c2c2c; QUAD $0x2c2c2c2c2c2c2c2c // .space 16, ',,,,,,,,,,,,,,,,'
//0x00000010 LCPI0_1
0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, //0x00000010 QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf'
//0x00000020 LCPI0_2
0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, //0x00000020 QUAD $0x5d5d5d5d5d5d5d5d; QUAD $0x5d5d5d5d5d5d5d5d // .space 16, ']]]]]]]]]]]]]]]]'
//0x00000030 LCPI0_3
0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, //0x00000030 QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""'
//0x00000040 LCPI0_4
0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, //0x00000040 QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
//0x00000050 LCPI0_5
0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, //0x00000050 QUAD $0x7b7b7b7b7b7b7b7b; QUAD $0x7b7b7b7b7b7b7b7b // .space 16, '{{{{{{{{{{{{{{{{'
//0x00000060 LCPI0_6
0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, //0x00000060 QUAD $0x7d7d7d7d7d7d7d7d; QUAD $0x7d7d7d7d7d7d7d7d // .space 16, '}}}}}}}}}}}}}}}}'
//0x00000070 LCPI0_7
0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, //0x00000070 QUAD $0x5b5b5b5b5b5b5b5b; QUAD $0x5b5b5b5b5b5b5b5b // .space 16, '[[[[[[[[[[[[[[[['
//0x00000080 LCPI0_8
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000080 .quad 1
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0x00000088 .quad 0
//0x00000090 LCPI0_9
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, //0x00000090 QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, ' '
//0x000000a0 LCPI0_10
0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, //0x000000a0 QUAD $0x2f2f2f2f2f2f2f2f; QUAD $0x2f2f2f2f2f2f2f2f // .space 16, '////////////////'
//0x000000b0 LCPI0_11
0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, //0x000000b0 QUAD $0x3a3a3a3a3a3a3a3a; QUAD $0x3a3a3a3a3a3a3a3a // .space 16, '::::::::::::::::'
//0x000000c0 LCPI0_12
0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, //0x000000c0 QUAD $0x2b2b2b2b2b2b2b2b; QUAD $0x2b2b2b2b2b2b2b2b // .space 16, '++++++++++++++++'
//0x000000d0 LCPI0_13
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, //0x000000d0 QUAD $0x2d2d2d2d2d2d2d2d; QUAD $0x2d2d2d2d2d2d2d2d // .space 16, '----------------'
//0x000000e0 LCPI0_14
0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, //0x000000e0 QUAD $0x2e2e2e2e2e2e2e2e; QUAD $0x2e2e2e2e2e2e2e2e // .space 16, '................'
//0x000000f0 LCPI0_15
0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, //0x000000f0 QUAD $0x4545454545454545; QUAD $0x4545454545454545 // .space 16, 'EEEEEEEEEEEEEEEE'
//0x00000100 .p2align 4, 0x90
//0x00000100 _skip_one
0x55, //0x00000100 pushq %rbp
0x48, 0x89, 0xe5, //0x00000101 movq %rsp, %rbp
0x41, 0x57, //0x00000104 pushq %r15
0x41, 0x56, //0x00000106 pushq %r14
0x41, 0x55, //0x00000108 pushq %r13
0x41, 0x54, //0x0000010a pushq %r12
0x53, //0x0000010c pushq %rbx
0x48, 0x81, 0xec, 0xb8, 0x00, 0x00, 0x00, //0x0000010d subq $184, %rsp
0x49, 0x89, 0xf0, //0x00000114 movq %rsi, %r8
0x48, 0x89, 0x8d, 0x68, 0xff, 0xff, 0xff, //0x00000117 movq %rcx, $-152(%rbp)
0xf6, 0xc1, 0x40, //0x0000011e testb $64, %cl
0x48, 0x89, 0x75, 0xd0, //0x00000121 movq %rsi, $-48(%rbp)
0x48, 0x89, 0x7d, 0xb0, //0x00000125 movq %rdi, $-80(%rbp)
0x0f, 0x85, 0xc2, 0x00, 0x00, 0x00, //0x00000129 jne LBB0_2
0x49, 0x89, 0xd3, //0x0000012f movq %rdx, %r11
0x0f, 0x10, 0x05, 0x47, 0xff, 0xff, 0xff, //0x00000132 movups $-185(%rip), %xmm0 /* LCPI0_8+0(%rip) */
0x0f, 0x11, 0x02, //0x00000139 movups %xmm0, (%rdx)
0x4c, 0x8b, 0x27, //0x0000013c movq (%rdi), %r12
0x4c, 0x89, 0xe0, //0x0000013f movq %r12, %rax
0x48, 0xf7, 0xd0, //0x00000142 notq %rax
0x48, 0x89, 0x45, 0x88, //0x00000145 movq %rax, $-120(%rbp)
0xb8, 0x01, 0x00, 0x00, 0x00, //0x00000149 movl $1, %eax
0x4c, 0x29, 0xe0, //0x0000014e subq %r12, %rax
0x48, 0x89, 0x45, 0x98, //0x00000151 movq %rax, $-104(%rbp)
0x4c, 0x89, 0xe0, //0x00000155 movq %r12, %rax
0x48, 0xf7, 0xd8, //0x00000158 negq %rax
0x48, 0x89, 0x45, 0x80, //0x0000015b movq %rax, $-128(%rbp)
0x49, 0x8d, 0x44, 0x24, 0xff, //0x0000015f leaq $-1(%r12), %rax
0x48, 0x89, 0x85, 0x78, 0xff, 0xff, 0xff, //0x00000164 movq %rax, $-136(%rbp)
0x49, 0x8d, 0x44, 0x24, 0xfe, //0x0000016b leaq $-2(%r12), %rax
0x48, 0x89, 0x85, 0x70, 0xff, 0xff, 0xff, //0x00000170 movq %rax, $-144(%rbp)
0x49, 0xc7, 0xc2, 0xff, 0xff, 0xff, 0xff, //0x00000177 movq $-1, %r10
0x49, 0xbe, 0x00, 0x26, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, //0x0000017e movabsq $4294977024, %r14
0xf3, 0x0f, 0x6f, 0x05, 0xa0, 0xfe, 0xff, 0xff, //0x00000188 movdqu $-352(%rip), %xmm0 /* LCPI0_3+0(%rip) */
0xf3, 0x0f, 0x6f, 0x0d, 0xa8, 0xfe, 0xff, 0xff, //0x00000190 movdqu $-344(%rip), %xmm1 /* LCPI0_4+0(%rip) */
0xf3, 0x0f, 0x6f, 0x15, 0xf0, 0xfe, 0xff, 0xff, //0x00000198 movdqu $-272(%rip), %xmm2 /* LCPI0_9+0(%rip) */
0x66, 0x45, 0x0f, 0x76, 0xff, //0x000001a0 pcmpeqd %xmm15, %xmm15
0xf3, 0x44, 0x0f, 0x6f, 0x05, 0xf2, 0xfe, 0xff, 0xff, //0x000001a5 movdqu $-270(%rip), %xmm8 /* LCPI0_10+0(%rip) */
0xf3, 0x44, 0x0f, 0x6f, 0x35, 0xf9, 0xfe, 0xff, 0xff, //0x000001ae movdqu $-263(%rip), %xmm14 /* LCPI0_11+0(%rip) */
0xf3, 0x44, 0x0f, 0x6f, 0x0d, 0x00, 0xff, 0xff, 0xff, //0x000001b7 movdqu $-256(%rip), %xmm9 /* LCPI0_12+0(%rip) */
0xf3, 0x44, 0x0f, 0x6f, 0x15, 0x07, 0xff, 0xff, 0xff, //0x000001c0 movdqu $-249(%rip), %xmm10 /* LCPI0_13+0(%rip) */
0xf3, 0x44, 0x0f, 0x6f, 0x1d, 0x3e, 0xfe, 0xff, 0xff, //0x000001c9 movdqu $-450(%rip), %xmm11 /* LCPI0_1+0(%rip) */
0xf3, 0x44, 0x0f, 0x6f, 0x25, 0x05, 0xff, 0xff, 0xff, //0x000001d2 movdqu $-251(%rip), %xmm12 /* LCPI0_14+0(%rip) */
0xf3, 0x44, 0x0f, 0x6f, 0x2d, 0x0c, 0xff, 0xff, 0xff, //0x000001db movdqu $-244(%rip), %xmm13 /* LCPI0_15+0(%rip) */
0x4c, 0x89, 0x65, 0xc0, //0x000001e4 movq %r12, $-64(%rbp)
0x48, 0x89, 0x55, 0xa8, //0x000001e8 movq %rdx, $-88(%rbp)
0xe9, 0x39, 0x01, 0x00, 0x00, //0x000001ec jmp LBB0_29
//0x000001f1 LBB0_2
0x4c, 0x8b, 0x27, //0x000001f1 movq (%rdi), %r12
0x48, 0x8b, 0x77, 0x08, //0x000001f4 movq $8(%rdi), %rsi
0x49, 0x8b, 0x18, //0x000001f8 movq (%r8), %rbx
0x48, 0x39, 0xf3, //0x000001fb cmpq %rsi, %rbx
0x0f, 0x83, 0x26, 0x00, 0x00, 0x00, //0x000001fe jae LBB0_7
0x41, 0x8a, 0x04, 0x1c, //0x00000204 movb (%r12,%rbx), %al
0x3c, 0x0d, //0x00000208 cmpb $13, %al
0x0f, 0x84, 0x1a, 0x00, 0x00, 0x00, //0x0000020a je LBB0_7
0x3c, 0x20, //0x00000210 cmpb $32, %al
0x0f, 0x84, 0x12, 0x00, 0x00, 0x00, //0x00000212 je LBB0_7
0x04, 0xf7, //0x00000218 addb $-9, %al
0x3c, 0x01, //0x0000021a cmpb $1, %al
0x0f, 0x86, 0x08, 0x00, 0x00, 0x00, //0x0000021c jbe LBB0_7
0x49, 0x89, 0xd9, //0x00000222 movq %rbx, %r9
0xe9, 0x46, 0x26, 0x00, 0x00, //0x00000225 jmp LBB0_492
//0x0000022a LBB0_7
0x4c, 0x8d, 0x4b, 0x01, //0x0000022a leaq $1(%rbx), %r9
0x49, 0x39, 0xf1, //0x0000022e cmpq %rsi, %r9
0x0f, 0x83, 0x1e, 0x00, 0x00, 0x00, //0x00000231 jae LBB0_11
0x43, 0x8a, 0x04, 0x0c, //0x00000237 movb (%r12,%r9), %al
0x3c, 0x0d, //0x0000023b cmpb $13, %al
0x0f, 0x84, 0x12, 0x00, 0x00, 0x00, //0x0000023d je LBB0_11
0x3c, 0x20, //0x00000243 cmpb $32, %al
0x0f, 0x84, 0x0a, 0x00, 0x00, 0x00, //0x00000245 je LBB0_11
0x04, 0xf7, //0x0000024b addb $-9, %al
0x3c, 0x01, //0x0000024d cmpb $1, %al
0x0f, 0x87, 0x1b, 0x26, 0x00, 0x00, //0x0000024f ja LBB0_492
//0x00000255 LBB0_11
0x4c, 0x8d, 0x4b, 0x02, //0x00000255 leaq $2(%rbx), %r9
0x49, 0x39, 0xf1, //0x00000259 cmpq %rsi, %r9
0x0f, 0x83, 0x1e, 0x00, 0x00, 0x00, //0x0000025c jae LBB0_15
0x43, 0x8a, 0x04, 0x0c, //0x00000262 movb (%r12,%r9), %al
0x3c, 0x0d, //0x00000266 cmpb $13, %al
0x0f, 0x84, 0x12, 0x00, 0x00, 0x00, //0x00000268 je LBB0_15
0x3c, 0x20, //0x0000026e cmpb $32, %al
0x0f, 0x84, 0x0a, 0x00, 0x00, 0x00, //0x00000270 je LBB0_15
0x04, 0xf7, //0x00000276 addb $-9, %al
0x3c, 0x01, //0x00000278 cmpb $1, %al
0x0f, 0x87, 0xf0, 0x25, 0x00, 0x00, //0x0000027a ja LBB0_492
//0x00000280 LBB0_15
0x4c, 0x8d, 0x4b, 0x03, //0x00000280 leaq $3(%rbx), %r9
0x49, 0x39, 0xf1, //0x00000284 cmpq %rsi, %r9
0x0f, 0x83, 0x1e, 0x00, 0x00, 0x00, //0x00000287 jae LBB0_19
0x43, 0x8a, 0x04, 0x0c, //0x0000028d movb (%r12,%r9), %al
0x3c, 0x0d, //0x00000291 cmpb $13, %al
0x0f, 0x84, 0x12, 0x00, 0x00, 0x00, //0x00000293 je LBB0_19
0x3c, 0x20, //0x00000299 cmpb $32, %al
0x0f, 0x84, 0x0a, 0x00, 0x00, 0x00, //0x0000029b je LBB0_19
0x04, 0xf7, //0x000002a1 addb $-9, %al
0x3c, 0x01, //0x000002a3 cmpb $1, %al
0x0f, 0x87, 0xc5, 0x25, 0x00, 0x00, //0x000002a5 ja LBB0_492
//0x000002ab LBB0_19
0x48, 0x83, 0xc3, 0x04, //0x000002ab addq $4, %rbx
0x48, 0x39, 0xde, //0x000002af cmpq %rbx, %rsi
0x0f, 0x86, 0x7b, 0x25, 0x00, 0x00, //0x000002b2 jbe LBB0_486
0x48, 0x39, 0xde, //0x000002b8 cmpq %rbx, %rsi
0x0f, 0x84, 0x90, 0x25, 0x00, 0x00, //0x000002bb je LBB0_489
0x49, 0x8d, 0x04, 0x34, //0x000002c1 leaq (%r12,%rsi), %rax
0x48, 0xb9, 0x00, 0x26, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, //0x000002c5 movabsq $4294977024, %rcx
0x90, //0x000002cf .p2align 4, 0x90
//0x000002d0 LBB0_22
0x41, 0x0f, 0xbe, 0x14, 0x1c, //0x000002d0 movsbl (%r12,%rbx), %edx
0x83, 0xfa, 0x20, //0x000002d5 cmpl $32, %edx
0x0f, 0x87, 0x7f, 0x25, 0x00, 0x00, //0x000002d8 ja LBB0_491
0x48, 0x0f, 0xa3, 0xd1, //0x000002de btq %rdx, %rcx
0x0f, 0x83, 0x75, 0x25, 0x00, 0x00, //0x000002e2 jae LBB0_491
0x48, 0x83, 0xc3, 0x01, //0x000002e8 addq $1, %rbx
0x48, 0x39, 0xde, //0x000002ec cmpq %rbx, %rsi
0x0f, 0x85, 0xdb, 0xff, 0xff, 0xff, //0x000002ef jne LBB0_22
0xe9, 0x5d, 0x25, 0x00, 0x00, //0x000002f5 jmp LBB0_490
//0x000002fa LBB0_25
0x49, 0x81, 0xfa, 0xff, 0x0f, 0x00, 0x00, //0x000002fa cmpq $4095, %r10
0x0f, 0x8f, 0x83, 0x26, 0x00, 0x00, //0x00000301 jg LBB0_597
0x49, 0x8d, 0x42, 0x01, //0x00000307 leaq $1(%r10), %rax
0x49, 0x89, 0x03, //0x0000030b movq %rax, (%r11)
0x4b, 0xc7, 0x44, 0xd3, 0x08, 0x00, 0x00, 0x00, 0x00, //0x0000030e movq $0, $8(%r11,%r10,8)
//0x00000317 LBB0_27
0x4c, 0x8b, 0x55, 0xb8, //0x00000317 movq $-72(%rbp), %r10
//0x0000031b LBB0_28
0x4d, 0x8b, 0x0b, //0x0000031b movq (%r11), %r9
0x4c, 0x89, 0xd0, //0x0000031e movq %r10, %rax
0x4d, 0x85, 0xc9, //0x00000321 testq %r9, %r9
0x0f, 0x84, 0xff, 0x30, 0x00, 0x00, //0x00000324 je LBB0_580
//0x0000032a LBB0_29
0x4c, 0x89, 0xd1, //0x0000032a movq %r10, %rcx
0x48, 0x8b, 0x47, 0x08, //0x0000032d movq $8(%rdi), %rax
0x49, 0x8b, 0x30, //0x00000331 movq (%r8), %rsi
0x48, 0x39, 0xc6, //0x00000334 cmpq %rax, %rsi
0x0f, 0x83, 0x33, 0x00, 0x00, 0x00, //0x00000337 jae LBB0_34
0x41, 0x8a, 0x14, 0x34, //0x0000033d movb (%r12,%rsi), %dl
0x80, 0xfa, 0x0d, //0x00000341 cmpb $13, %dl
0x0f, 0x84, 0x26, 0x00, 0x00, 0x00, //0x00000344 je LBB0_34
0x80, 0xfa, 0x20, //0x0000034a cmpb $32, %dl
0x0f, 0x84, 0x1d, 0x00, 0x00, 0x00, //0x0000034d je LBB0_34
0x80, 0xc2, 0xf7, //0x00000353 addb $-9, %dl
0x80, 0xfa, 0x01, //0x00000356 cmpb $1, %dl
0x0f, 0x86, 0x11, 0x00, 0x00, 0x00, //0x00000359 jbe LBB0_34
0x48, 0x89, 0xf3, //0x0000035f movq %rsi, %rbx
0xe9, 0x01, 0x01, 0x00, 0x00, //0x00000362 jmp LBB0_55
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x00000367 .p2align 4, 0x90
//0x00000370 LBB0_34
0x48, 0x8d, 0x5e, 0x01, //0x00000370 leaq $1(%rsi), %rbx
0x48, 0x39, 0xc3, //0x00000374 cmpq %rax, %rbx
0x0f, 0x83, 0x23, 0x00, 0x00, 0x00, //0x00000377 jae LBB0_38
0x41, 0x8a, 0x14, 0x1c, //0x0000037d movb (%r12,%rbx), %dl
0x80, 0xfa, 0x0d, //0x00000381 cmpb $13, %dl
0x0f, 0x84, 0x16, 0x00, 0x00, 0x00, //0x00000384 je LBB0_38
0x80, 0xfa, 0x20, //0x0000038a cmpb $32, %dl
0x0f, 0x84, 0x0d, 0x00, 0x00, 0x00, //0x0000038d je LBB0_38
0x80, 0xc2, 0xf7, //0x00000393 addb $-9, %dl
0x80, 0xfa, 0x01, //0x00000396 cmpb $1, %dl
0x0f, 0x87, 0xc9, 0x00, 0x00, 0x00, //0x00000399 ja LBB0_55
0x90, //0x0000039f .p2align 4, 0x90
//0x000003a0 LBB0_38
0x48, 0x8d, 0x5e, 0x02, //0x000003a0 leaq $2(%rsi), %rbx
0x48, 0x39, 0xc3, //0x000003a4 cmpq %rax, %rbx
0x0f, 0x83, 0x23, 0x00, 0x00, 0x00, //0x000003a7 jae LBB0_42
0x41, 0x8a, 0x14, 0x1c, //0x000003ad movb (%r12,%rbx), %dl
0x80, 0xfa, 0x0d, //0x000003b1 cmpb $13, %dl
0x0f, 0x84, 0x16, 0x00, 0x00, 0x00, //0x000003b4 je LBB0_42
0x80, 0xfa, 0x20, //0x000003ba cmpb $32, %dl
0x0f, 0x84, 0x0d, 0x00, 0x00, 0x00, //0x000003bd je LBB0_42
0x80, 0xc2, 0xf7, //0x000003c3 addb $-9, %dl
0x80, 0xfa, 0x01, //0x000003c6 cmpb $1, %dl
0x0f, 0x87, 0x99, 0x00, 0x00, 0x00, //0x000003c9 ja LBB0_55
0x90, //0x000003cf .p2align 4, 0x90
//0x000003d0 LBB0_42
0x48, 0x8d, 0x5e, 0x03, //0x000003d0 leaq $3(%rsi), %rbx
0x48, 0x39, 0xc3, //0x000003d4 cmpq %rax, %rbx
0x0f, 0x83, 0x23, 0x00, 0x00, 0x00, //0x000003d7 jae LBB0_46
0x41, 0x8a, 0x14, 0x1c, //0x000003dd movb (%r12,%rbx), %dl
0x80, 0xfa, 0x0d, //0x000003e1 cmpb $13, %dl
0x0f, 0x84, 0x16, 0x00, 0x00, 0x00, //0x000003e4 je LBB0_46
0x80, 0xfa, 0x20, //0x000003ea cmpb $32, %dl
0x0f, 0x84, 0x0d, 0x00, 0x00, 0x00, //0x000003ed je LBB0_46
0x80, 0xc2, 0xf7, //0x000003f3 addb $-9, %dl
0x80, 0xfa, 0x01, //0x000003f6 cmpb $1, %dl
0x0f, 0x87, 0x69, 0x00, 0x00, 0x00, //0x000003f9 ja LBB0_55
0x90, //0x000003ff .p2align 4, 0x90
//0x00000400 LBB0_46
0x48, 0x83, 0xc6, 0x04, //0x00000400 addq $4, %rsi
0x48, 0x39, 0xf0, //0x00000404 cmpq %rsi, %rax
0x0f, 0x86, 0x35, 0x24, 0x00, 0x00, //0x00000407 jbe LBB0_487
0x48, 0x39, 0xf0, //0x0000040d cmpq %rsi, %rax
0x0f, 0x84, 0x3a, 0x00, 0x00, 0x00, //0x00000410 je LBB0_52
0x49, 0x8d, 0x14, 0x04, //0x00000416 leaq (%r12,%rax), %rdx
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x0000041a .p2align 4, 0x90
//0x00000420 LBB0_49
0x41, 0x0f, 0xbe, 0x1c, 0x34, //0x00000420 movsbl (%r12,%rsi), %ebx
0x83, 0xfb, 0x20, //0x00000425 cmpl $32, %ebx
0x0f, 0x87, 0x2e, 0x00, 0x00, 0x00, //0x00000428 ja LBB0_54
0x49, 0x0f, 0xa3, 0xde, //0x0000042e btq %rbx, %r14
0x0f, 0x83, 0x24, 0x00, 0x00, 0x00, //0x00000432 jae LBB0_54
0x48, 0x83, 0xc6, 0x01, //0x00000438 addq $1, %rsi
0x48, 0x39, 0xf0, //0x0000043c cmpq %rsi, %rax
0x0f, 0x85, 0xdb, 0xff, 0xff, 0xff, //0x0000043f jne LBB0_49
0xe9, 0x0c, 0x00, 0x00, 0x00, //0x00000445 jmp LBB0_53
0x90, 0x90, 0x90, 0x90, 0x90, 0x90, //0x0000044a .p2align 4, 0x90
//0x00000450 LBB0_52
0x4c, 0x01, 0xe6, //0x00000450 addq %r12, %rsi
0x48, 0x89, 0xf2, //0x00000453 movq %rsi, %rdx
//0x00000456 LBB0_53
0x4c, 0x29, 0xe2, //0x00000456 subq %r12, %rdx
0x48, 0x89, 0xd6, //0x00000459 movq %rdx, %rsi
//0x0000045c LBB0_54
0x48, 0x89, 0xf3, //0x0000045c movq %rsi, %rbx
0x48, 0x39, 0xc6, //0x0000045f cmpq %rax, %rsi
0x0f, 0x83, 0xdd, 0x23, 0x00, 0x00, //0x00000462 jae LBB0_488
//0x00000468 LBB0_55
0x48, 0x8d, 0x43, 0x01, //0x00000468 leaq $1(%rbx), %rax
0x49, 0x89, 0x00, //0x0000046c movq %rax, (%r8)
0x41, 0x0f, 0xbe, 0x14, 0x1c, //0x0000046f movsbl (%r12,%rbx), %edx
0x48, 0xc7, 0xc0, 0xff, 0xff, 0xff, 0xff, //0x00000474 movq $-1, %rax
0x85, 0xd2, //0x0000047b testl %edx, %edx
0x0f, 0x84, 0xa6, 0x2f, 0x00, 0x00, //0x0000047d je LBB0_580
0x48, 0x89, 0xde, //0x00000483 movq %rbx, %rsi
0x4d, 0x8b, 0x13, //0x00000486 movq (%r11), %r10
0x4d, 0x8d, 0x4a, 0xff, //0x00000489 leaq $-1(%r10), %r9
0x43, 0x8b, 0x1c, 0xd3, //0x0000048d movl (%r11,%r10,8), %ebx
0x48, 0x83, 0xf9, 0xff, //0x00000491 cmpq $-1, %rcx
0x48, 0x0f, 0x45, 0xf1, //0x00000495 cmovneq %rcx, %rsi
0x48, 0x89, 0x75, 0xb8, //0x00000499 movq %rsi, $-72(%rbp)
0x83, 0xc3, 0xff, //0x0000049d addl $-1, %ebx
0x83, 0xfb, 0x05, //0x000004a0 cmpl $5, %ebx
0x0f, 0x87, 0x5e, 0x02, 0x00, 0x00, //0x000004a3 ja LBB0_88
0x48, 0x8d, 0x35, 0x78, 0x34, 0x00, 0x00, //0x000004a9 leaq $13432(%rip), %rsi /* LJTI0_1+0(%rip) */
0x48, 0x63, 0x0c, 0x9e, //0x000004b0 movslq (%rsi,%rbx,4), %rcx
0x48, 0x01, 0xf1, //0x000004b4 addq %rsi, %rcx
0xff, 0xe1, //0x000004b7 jmpq *%rcx
//0x000004b9 LBB0_58
0x83, 0xfa, 0x2c, //0x000004b9 cmpl $44, %edx
0x0f, 0x84, 0x38, 0xfe, 0xff, 0xff, //0x000004bc je LBB0_25
0x83, 0xfa, 0x5d, //0x000004c2 cmpl $93, %edx
0x0f, 0x84, 0x24, 0x02, 0x00, 0x00, //0x000004c5 je LBB0_87
0xe9, 0x32, 0x2f, 0x00, 0x00, //0x000004cb jmp LBB0_579
//0x000004d0 LBB0_60
0x80, 0xfa, 0x5d, //0x000004d0 cmpb $93, %dl
0x0f, 0x84, 0x16, 0x02, 0x00, 0x00, //0x000004d3 je LBB0_87
0x4b, 0xc7, 0x04, 0xd3, 0x01, 0x00, 0x00, 0x00, //0x000004d9 movq $1, (%r11,%r10,8)
0xe9, 0x24, 0x02, 0x00, 0x00, //0x000004e1 jmp LBB0_89
//0x000004e6 LBB0_62
0x80, 0xfa, 0x22, //0x000004e6 cmpb $34, %dl
0x0f, 0x85, 0x13, 0x2f, 0x00, 0x00, //0x000004e9 jne LBB0_579
0x4b, 0xc7, 0x04, 0xd3, 0x04, 0x00, 0x00, 0x00, //0x000004ef movq $4, (%r11,%r10,8)
0x49, 0x8b, 0x08, //0x000004f7 movq (%r8), %rcx
0x48, 0x8b, 0x47, 0x08, //0x000004fa movq $8(%rdi), %rax
0xf6, 0x85, 0x68, 0xff, 0xff, 0xff, 0x20, //0x000004fe testb $32, $-152(%rbp)
0x48, 0x89, 0x45, 0xa0, //0x00000505 movq %rax, $-96(%rbp)
0x48, 0x89, 0x4d, 0x90, //0x00000509 movq %rcx, $-112(%rbp)
0x0f, 0x85, 0xf9, 0x05, 0x00, 0x00, //0x0000050d jne LBB0_145
0x49, 0x89, 0xc1, //0x00000513 movq %rax, %r9
0x49, 0x29, 0xc9, //0x00000516 subq %rcx, %r9
0x0f, 0x84, 0x23, 0x31, 0x00, 0x00, //0x00000519 je LBB0_614
0x49, 0x83, 0xf9, 0x40, //0x0000051f cmpq $64, %r9
0x0f, 0x82, 0x1a, 0x1b, 0x00, 0x00, //0x00000523 jb LBB0_406
0x49, 0x89, 0xce, //0x00000529 movq %rcx, %r14
0x49, 0xf7, 0xd6, //0x0000052c notq %r14
0x48, 0xc7, 0x45, 0xc8, 0xff, 0xff, 0xff, 0xff, //0x0000052f movq $-1, $-56(%rbp)
0x48, 0x89, 0xc8, //0x00000537 movq %rcx, %rax
0x45, 0x31, 0xc0, //0x0000053a xorl %r8d, %r8d
0x90, 0x90, 0x90, //0x0000053d .p2align 4, 0x90
//0x00000540 LBB0_67
0xf3, 0x41, 0x0f, 0x6f, 0x1c, 0x04, //0x00000540 movdqu (%r12,%rax), %xmm3
0xf3, 0x41, 0x0f, 0x6f, 0x64, 0x04, 0x10, //0x00000546 movdqu $16(%r12,%rax), %xmm4
0xf3, 0x41, 0x0f, 0x6f, 0x6c, 0x04, 0x20, //0x0000054d movdqu $32(%r12,%rax), %xmm5
0xf3, 0x41, 0x0f, 0x6f, 0x74, 0x04, 0x30, //0x00000554 movdqu $48(%r12,%rax), %xmm6
0x66, 0x0f, 0x6f, 0xfb, //0x0000055b movdqa %xmm3, %xmm7
0x66, 0x0f, 0x74, 0xf8, //0x0000055f pcmpeqb %xmm0, %xmm7
0x66, 0x44, 0x0f, 0xd7, 0xd7, //0x00000563 pmovmskb %xmm7, %r10d
0x66, 0x0f, 0x6f, 0xfc, //0x00000568 movdqa %xmm4, %xmm7
0x66, 0x0f, 0x74, 0xf8, //0x0000056c pcmpeqb %xmm0, %xmm7
0x66, 0x0f, 0xd7, 0xdf, //0x00000570 pmovmskb %xmm7, %ebx
0x66, 0x0f, 0x6f, 0xfd, //0x00000574 movdqa %xmm5, %xmm7
0x66, 0x0f, 0x74, 0xf8, //0x00000578 pcmpeqb %xmm0, %xmm7
0x66, 0x0f, 0xd7, 0xff, //0x0000057c pmovmskb %xmm7, %edi
0x66, 0x0f, 0x6f, 0xfe, //0x00000580 movdqa %xmm6, %xmm7
0x66, 0x0f, 0x74, 0xf8, //0x00000584 pcmpeqb %xmm0, %xmm7
0x66, 0x0f, 0xd7, 0xd7, //0x00000588 pmovmskb %xmm7, %edx
0x66, 0x0f, 0x74, 0xd9, //0x0000058c pcmpeqb %xmm1, %xmm3
0x66, 0x44, 0x0f, 0xd7, 0xdb, //0x00000590 pmovmskb %xmm3, %r11d
0x66, 0x0f, 0x74, 0xe1, //0x00000595 pcmpeqb %xmm1, %xmm4
0x66, 0x0f, 0xd7, 0xcc, //0x00000599 pmovmskb %xmm4, %ecx
0x66, 0x0f, 0x74, 0xe9, //0x0000059d pcmpeqb %xmm1, %xmm5
0x66, 0x0f, 0xd7, 0xf5, //0x000005a1 pmovmskb %xmm5, %esi
0x66, 0x0f, 0x74, 0xf1, //0x000005a5 pcmpeqb %xmm1, %xmm6
0x66, 0x44, 0x0f, 0xd7, 0xfe, //0x000005a9 pmovmskb %xmm6, %r15d
0x48, 0xc1, 0xe2, 0x30, //0x000005ae shlq $48, %rdx
0x48, 0xc1, 0xe7, 0x20, //0x000005b2 shlq $32, %rdi
0x48, 0x09, 0xd7, //0x000005b6 orq %rdx, %rdi
0x48, 0xc1, 0xe3, 0x10, //0x000005b9 shlq $16, %rbx
0x48, 0x09, 0xfb, //0x000005bd orq %rdi, %rbx
0x49, 0x09, 0xda, //0x000005c0 orq %rbx, %r10
0x49, 0xc1, 0xe7, 0x30, //0x000005c3 shlq $48, %r15
0x48, 0xc1, 0xe6, 0x20, //0x000005c7 shlq $32, %rsi
0x4c, 0x09, 0xfe, //0x000005cb orq %r15, %rsi
0x48, 0xc1, 0xe1, 0x10, //0x000005ce shlq $16, %rcx
0x48, 0x09, 0xf1, //0x000005d2 orq %rsi, %rcx
0x49, 0x09, 0xcb, //0x000005d5 orq %rcx, %r11
0x0f, 0x85, 0x30, 0x00, 0x00, 0x00, //0x000005d8 jne LBB0_76
0x4d, 0x85, 0xc0, //0x000005de testq %r8, %r8
0x0f, 0x85, 0x3d, 0x00, 0x00, 0x00, //0x000005e1 jne LBB0_78
0x45, 0x31, 0xc0, //0x000005e7 xorl %r8d, %r8d
0x4d, 0x85, 0xd2, //0x000005ea testq %r10, %r10
0x0f, 0x85, 0x83, 0x00, 0x00, 0x00, //0x000005ed jne LBB0_79
//0x000005f3 LBB0_70
0x49, 0x83, 0xc1, 0xc0, //0x000005f3 addq $-64, %r9
0x49, 0x83, 0xc6, 0xc0, //0x000005f7 addq $-64, %r14
0x48, 0x83, 0xc0, 0x40, //0x000005fb addq $64, %rax
0x49, 0x83, 0xf9, 0x3f, //0x000005ff cmpq $63, %r9
0x0f, 0x87, 0x37, 0xff, 0xff, 0xff, //0x00000603 ja LBB0_67
0xe9, 0xf3, 0x12, 0x00, 0x00, //0x00000609 jmp LBB0_71
//0x0000060e LBB0_76
0x48, 0x83, 0x7d, 0xc8, 0xff, //0x0000060e cmpq $-1, $-56(%rbp)
0x0f, 0x85, 0x0b, 0x00, 0x00, 0x00, //0x00000613 jne LBB0_78
0x49, 0x0f, 0xbc, 0xcb, //0x00000619 bsfq %r11, %rcx
0x48, 0x01, 0xc1, //0x0000061d addq %rax, %rcx
0x48, 0x89, 0x4d, 0xc8, //0x00000620 movq %rcx, $-56(%rbp)
//0x00000624 LBB0_78
0x4c, 0x89, 0xc1, //0x00000624 movq %r8, %rcx
0x48, 0xf7, 0xd1, //0x00000627 notq %rcx
0x4c, 0x21, 0xd9, //0x0000062a andq %r11, %rcx
0x48, 0x8d, 0x14, 0x09, //0x0000062d leaq (%rcx,%rcx), %rdx
0x4c, 0x09, 0xc2, //0x00000631 orq %r8, %rdx
0x48, 0x89, 0xd6, //0x00000634 movq %rdx, %rsi
0x48, 0xf7, 0xd6, //0x00000637 notq %rsi
0x4c, 0x21, 0xde, //0x0000063a andq %r11, %rsi
0x48, 0xbf, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, //0x0000063d movabsq $-6148914691236517206, %rdi
0x48, 0x21, 0xfe, //0x00000647 andq %rdi, %rsi
0x45, 0x31, 0xc0, //0x0000064a xorl %r8d, %r8d
0x48, 0x01, 0xce, //0x0000064d addq %rcx, %rsi
0x41, 0x0f, 0x92, 0xc0, //0x00000650 setb %r8b
0x48, 0x01, 0xf6, //0x00000654 addq %rsi, %rsi
0x48, 0xb9, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, //0x00000657 movabsq $6148914691236517205, %rcx
0x48, 0x31, 0xce, //0x00000661 xorq %rcx, %rsi
0x48, 0x21, 0xd6, //0x00000664 andq %rdx, %rsi
0x48, 0xf7, 0xd6, //0x00000667 notq %rsi
0x49, 0x21, 0xf2, //0x0000066a andq %rsi, %r10
0x4d, 0x85, 0xd2, //0x0000066d testq %r10, %r10
0x0f, 0x84, 0x7d, 0xff, 0xff, 0xff, //0x00000670 je LBB0_70
//0x00000676 LBB0_79
0x49, 0x0f, 0xbc, 0xc2, //0x00000676 bsfq %r10, %rax
0x4c, 0x29, 0xf0, //0x0000067a subq %r14, %rax
0x4c, 0x8b, 0x45, 0xd0, //0x0000067d movq $-48(%rbp), %r8
0x48, 0x8b, 0x7d, 0xb0, //0x00000681 movq $-80(%rbp), %rdi
0x4c, 0x8b, 0x5d, 0xa8, //0x00000685 movq $-88(%rbp), %r11
0x49, 0xbe, 0x00, 0x26, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, //0x00000689 movabsq $4294977024, %r14
0x4c, 0x8b, 0x55, 0xb8, //0x00000693 movq $-72(%rbp), %r10
0xe9, 0x80, 0x09, 0x00, 0x00, //0x00000697 jmp LBB0_215
//0x0000069c LBB0_80
0x83, 0xfa, 0x2c, //0x0000069c cmpl $44, %edx
0x0f, 0x85, 0x41, 0x00, 0x00, 0x00, //0x0000069f jne LBB0_86
0x49, 0x81, 0xfa, 0xff, 0x0f, 0x00, 0x00, //0x000006a5 cmpq $4095, %r10
0x0f, 0x8f, 0xd8, 0x22, 0x00, 0x00, //0x000006ac jg LBB0_597
0x49, 0x8d, 0x42, 0x01, //0x000006b2 leaq $1(%r10), %rax
0x49, 0x89, 0x03, //0x000006b6 movq %rax, (%r11)
0x4b, 0xc7, 0x44, 0xd3, 0x08, 0x03, 0x00, 0x00, 0x00, //0x000006b9 movq $3, $8(%r11,%r10,8)
0xe9, 0x50, 0xfc, 0xff, 0xff, //0x000006c2 jmp LBB0_27
//0x000006c7 LBB0_83
0x80, 0xfa, 0x3a, //0x000006c7 cmpb $58, %dl
0x0f, 0x85, 0x32, 0x2d, 0x00, 0x00, //0x000006ca jne LBB0_579
0x4b, 0xc7, 0x04, 0xd3, 0x00, 0x00, 0x00, 0x00, //0x000006d0 movq $0, (%r11,%r10,8)
0xe9, 0x3a, 0xfc, 0xff, 0xff, //0x000006d8 jmp LBB0_27
//0x000006dd LBB0_85
0x83, 0xfa, 0x22, //0x000006dd cmpl $34, %edx
0x0f, 0x84, 0x82, 0x02, 0x00, 0x00, //0x000006e0 je LBB0_127
//0x000006e6 LBB0_86
0x83, 0xfa, 0x7d, //0x000006e6 cmpl $125, %edx
0x0f, 0x85, 0x13, 0x2d, 0x00, 0x00, //0x000006e9 jne LBB0_579
//0x000006ef LBB0_87
0x4d, 0x89, 0x0b, //0x000006ef movq %r9, (%r11)
0x4c, 0x8b, 0x55, 0xb8, //0x000006f2 movq $-72(%rbp), %r10
0x4c, 0x89, 0xd0, //0x000006f6 movq %r10, %rax
0x4d, 0x85, 0xc9, //0x000006f9 testq %r9, %r9
0x0f, 0x85, 0x28, 0xfc, 0xff, 0xff, //0x000006fc jne LBB0_29
0xe9, 0x22, 0x2d, 0x00, 0x00, //0x00000702 jmp LBB0_580
//0x00000707 LBB0_88
0x4d, 0x89, 0x0b, //0x00000707 movq %r9, (%r11)
//0x0000070a LBB0_89
0x83, 0xfa, 0x7b, //0x0000070a cmpl $123, %edx
0x4c, 0x8b, 0x55, 0xb8, //0x0000070d movq $-72(%rbp), %r10
0x0f, 0x87, 0xeb, 0x2c, 0x00, 0x00, //0x00000711 ja LBB0_579
0x89, 0xd1, //0x00000717 movl %edx, %ecx
0x48, 0x8d, 0x15, 0x20, 0x32, 0x00, 0x00, //0x00000719 leaq $12832(%rip), %rdx /* LJTI0_2+0(%rip) */
0x48, 0x63, 0x0c, 0x8a, //0x00000720 movslq (%rdx,%rcx,4), %rcx
0x48, 0x01, 0xd1, //0x00000724 addq %rdx, %rcx
0xff, 0xe1, //0x00000727 jmpq *%rcx
//0x00000729 LBB0_91
0x4c, 0x8b, 0x57, 0x08, //0x00000729 movq $8(%rdi), %r10
0x4d, 0x8b, 0x08, //0x0000072d movq (%r8), %r9
0x49, 0x8d, 0x41, 0xff, //0x00000730 leaq $-1(%r9), %rax
0x49, 0x29, 0xc2, //0x00000734 subq %rax, %r10
0x0f, 0x84, 0xb0, 0x2c, 0x00, 0x00, //0x00000737 je LBB0_577
0x4f, 0x8d, 0x1c, 0x0c, //0x0000073d leaq (%r12,%r9), %r11
0x49, 0x83, 0xc3, 0xff, //0x00000741 addq $-1, %r11
0x41, 0x80, 0x3b, 0x30, //0x00000745 cmpb $48, (%r11)
0x0f, 0x85, 0x3b, 0x00, 0x00, 0x00, //0x00000749 jne LBB0_96
0x41, 0xbd, 0x01, 0x00, 0x00, 0x00, //0x0000074f movl $1, %r13d
0x49, 0x83, 0xfa, 0x01, //0x00000755 cmpq $1, %r10
0x0f, 0x84, 0x5c, 0x08, 0x00, 0x00, //0x00000759 je LBB0_211
0x48, 0x8b, 0x4d, 0xc0, //0x0000075f movq $-64(%rbp), %rcx
0x42, 0x8a, 0x0c, 0x09, //0x00000763 movb (%rcx,%r9), %cl
0x80, 0xc1, 0xd2, //0x00000767 addb $-46, %cl
0x80, 0xf9, 0x37, //0x0000076a cmpb $55, %cl
0x0f, 0x87, 0x48, 0x08, 0x00, 0x00, //0x0000076d ja LBB0_211
0x0f, 0xb6, 0xc9, //0x00000773 movzbl %cl, %ecx
0x48, 0xba, 0x01, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, //0x00000776 movabsq $36028797027352577, %rdx
0x48, 0x0f, 0xa3, 0xca, //0x00000780 btq %rcx, %rdx
0x0f, 0x83, 0x31, 0x08, 0x00, 0x00, //0x00000784 jae LBB0_211
//0x0000078a LBB0_96
0x49, 0x83, 0xfa, 0x10, //0x0000078a cmpq $16, %r10
0x0f, 0x82, 0xe8, 0x17, 0x00, 0x00, //0x0000078e jb LBB0_390
0x49, 0xc7, 0xc7, 0xff, 0xff, 0xff, 0xff, //0x00000794 movq $-1, %r15
0x45, 0x31, 0xed, //0x0000079b xorl %r13d, %r13d
0x49, 0xc7, 0xc6, 0xff, 0xff, 0xff, 0xff, //0x0000079e movq $-1, %r14
0x49, 0xc7, 0xc4, 0xff, 0xff, 0xff, 0xff, //0x000007a5 movq $-1, %r12
0x4c, 0x89, 0xd7, //0x000007ac movq %r10, %rdi
0x90, //0x000007af .p2align 4, 0x90
//0x000007b0 LBB0_98
0xf3, 0x43, 0x0f, 0x6f, 0x1c, 0x2b, //0x000007b0 movdqu (%r11,%r13), %xmm3
0x66, 0x0f, 0x6f, 0xe3, //0x000007b6 movdqa %xmm3, %xmm4
0x66, 0x41, 0x0f, 0x64, 0xe0, //0x000007ba pcmpgtb %xmm8, %xmm4
0x66, 0x41, 0x0f, 0x6f, 0xee, //0x000007bf movdqa %xmm14, %xmm5
0x66, 0x0f, 0x64, 0xeb, //0x000007c4 pcmpgtb %xmm3, %xmm5
0x66, 0x0f, 0xdb, 0xec, //0x000007c8 pand %xmm4, %xmm5
0x66, 0x0f, 0x6f, 0xe3, //0x000007cc movdqa %xmm3, %xmm4
0x66, 0x41, 0x0f, 0x74, 0xe1, //0x000007d0 pcmpeqb %xmm9, %xmm4
0x66, 0x0f, 0x6f, 0xf3, //0x000007d5 movdqa %xmm3, %xmm6
0x66, 0x41, 0x0f, 0x74, 0xf2, //0x000007d9 pcmpeqb %xmm10, %xmm6
0x66, 0x0f, 0xeb, 0xf4, //0x000007de por %xmm4, %xmm6
0x66, 0x0f, 0x6f, 0xe3, //0x000007e2 movdqa %xmm3, %xmm4
0x66, 0x41, 0x0f, 0xdb, 0xe3, //0x000007e6 pand %xmm11, %xmm4
0x66, 0x41, 0x0f, 0x74, 0xdc, //0x000007eb pcmpeqb %xmm12, %xmm3
0x66, 0x41, 0x0f, 0x74, 0xe5, //0x000007f0 pcmpeqb %xmm13, %xmm4
0x66, 0x0f, 0xd7, 0xf4, //0x000007f5 pmovmskb %xmm4, %esi
0x66, 0x0f, 0xeb, 0xe3, //0x000007f9 por %xmm3, %xmm4
0x66, 0x0f, 0xeb, 0xee, //0x000007fd por %xmm6, %xmm5
0x66, 0x0f, 0xeb, 0xec, //0x00000801 por %xmm4, %xmm5
0x66, 0x0f, 0xd7, 0xdb, //0x00000805 pmovmskb %xmm3, %ebx
0x66, 0x44, 0x0f, 0xd7, 0xc6, //0x00000809 pmovmskb %xmm6, %r8d
0x66, 0x0f, 0xd7, 0xcd, //0x0000080e pmovmskb %xmm5, %ecx
0xf7, 0xd1, //0x00000812 notl %ecx
0x0f, 0xbc, 0xc9, //0x00000814 bsfl %ecx, %ecx
0x83, 0xf9, 0x10, //0x00000817 cmpl $16, %ecx
0x0f, 0x84, 0x13, 0x00, 0x00, 0x00, //0x0000081a je LBB0_100
0xba, 0xff, 0xff, 0xff, 0xff, //0x00000820 movl $-1, %edx
0xd3, 0xe2, //0x00000825 shll %cl, %edx
0xf7, 0xd2, //0x00000827 notl %edx
0x21, 0xd3, //0x00000829 andl %edx, %ebx
0x21, 0xd6, //0x0000082b andl %edx, %esi
0x44, 0x21, 0xc2, //0x0000082d andl %r8d, %edx
0x41, 0x89, 0xd0, //0x00000830 movl %edx, %r8d
//0x00000833 LBB0_100
0x8d, 0x53, 0xff, //0x00000833 leal $-1(%rbx), %edx
0x21, 0xda, //0x00000836 andl %ebx, %edx
0x0f, 0x85, 0x79, 0x10, 0x00, 0x00, //0x00000838 jne LBB0_349
0x8d, 0x56, 0xff, //0x0000083e leal $-1(%rsi), %edx
0x21, 0xf2, //0x00000841 andl %esi, %edx
0x0f, 0x85, 0x6e, 0x10, 0x00, 0x00, //0x00000843 jne LBB0_349
0x41, 0x8d, 0x50, 0xff, //0x00000849 leal $-1(%r8), %edx
0x44, 0x21, 0xc2, //0x0000084d andl %r8d, %edx
0x0f, 0x85, 0x61, 0x10, 0x00, 0x00, //0x00000850 jne LBB0_349
0x85, 0xdb, //0x00000856 testl %ebx, %ebx
0x0f, 0x84, 0x13, 0x00, 0x00, 0x00, //0x00000858 je LBB0_106
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | true |
kubev2v/forklift | https://github.com/kubev2v/forklift/blob/b3b4703e958c25d54c4d48138d9e80ae32fadac3/vendor/github.com/bytedance/sonic/internal/native/sse/lookup_small_key_subr.go | vendor/github.com/bytedance/sonic/internal/native/sse/lookup_small_key_subr.go | // +build !noasm !appengine
// Code generated by asm2asm, DO NOT EDIT.
package sse
import (
`github.com/bytedance/sonic/loader`
)
const (
_entry__lookup_small_key = 48
)
const (
_stack__lookup_small_key = 88
)
const (
_size__lookup_small_key = 908
)
var (
_pcsp__lookup_small_key = [][2]uint32{
{0x1, 0},
{0x6, 8},
{0x8, 16},
{0xa, 24},
{0xc, 32},
{0xd, 40},
{0x11, 48},
{0x362, 88},
{0x363, 48},
{0x365, 40},
{0x367, 32},
{0x369, 24},
{0x36b, 16},
{0x36c, 8},
{0x36d, 0},
{0x38c, 88},
}
)
var _cfunc_lookup_small_key = []loader.CFunc{
{"_lookup_small_key_entry", 0, _entry__lookup_small_key, 0, nil},
{"_lookup_small_key", _entry__lookup_small_key, _size__lookup_small_key, _stack__lookup_small_key, _pcsp__lookup_small_key},
}
| go | Apache-2.0 | b3b4703e958c25d54c4d48138d9e80ae32fadac3 | 2026-01-07T09:44:30.792320Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.