summaryrefslogtreecommitdiff
path: root/vendor/github.com/bytedance/sonic/internal/encoder/ir/op.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/bytedance/sonic/internal/encoder/ir/op.go')
-rw-r--r--vendor/github.com/bytedance/sonic/internal/encoder/ir/op.go473
1 files changed, 0 insertions, 473 deletions
diff --git a/vendor/github.com/bytedance/sonic/internal/encoder/ir/op.go b/vendor/github.com/bytedance/sonic/internal/encoder/ir/op.go
deleted file mode 100644
index a0c693f00..000000000
--- a/vendor/github.com/bytedance/sonic/internal/encoder/ir/op.go
+++ /dev/null
@@ -1,473 +0,0 @@
-/*
- * Copyright 2021 ByteDance Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package ir
-
-import (
- "fmt"
- "reflect"
- "strconv"
- "strings"
- "unsafe"
-
- "github.com/bytedance/sonic/internal/encoder/vars"
- "github.com/bytedance/sonic/internal/rt"
-)
-
-type Op uint8
-
-const (
- OP_null Op = iota + 1
- OP_empty_arr
- OP_empty_obj
- OP_bool
- OP_i8
- OP_i16
- OP_i32
- OP_i64
- OP_u8
- OP_u16
- OP_u32
- OP_u64
- OP_f32
- OP_f64
- OP_str
- OP_bin
- OP_quote
- OP_number
- OP_eface
- OP_iface
- OP_byte
- OP_text
- OP_deref
- OP_index
- OP_load
- OP_save
- OP_drop
- OP_drop_2
- OP_recurse
- OP_is_nil
- OP_is_nil_p1
- OP_is_zero_1
- OP_is_zero_2
- OP_is_zero_4
- OP_is_zero_8
- OP_is_zero_map
- OP_goto
- OP_map_iter
- OP_map_stop
- OP_map_check_key
- OP_map_write_key
- OP_map_value_next
- OP_slice_len
- OP_slice_next
- OP_marshal
- OP_marshal_p
- OP_marshal_text
- OP_marshal_text_p
- OP_cond_set
- OP_cond_testc
-)
-
-const (
- _INT_SIZE = 32 << (^uint(0) >> 63)
- _PTR_SIZE = 32 << (^uintptr(0) >> 63)
- _PTR_BYTE = unsafe.Sizeof(uintptr(0))
-)
-
-const OpSize = unsafe.Sizeof(NewInsOp(0))
-
-var OpNames = [256]string{
- OP_null: "null",
- OP_empty_arr: "empty_arr",
- OP_empty_obj: "empty_obj",
- OP_bool: "bool",
- OP_i8: "i8",
- OP_i16: "i16",
- OP_i32: "i32",
- OP_i64: "i64",
- OP_u8: "u8",
- OP_u16: "u16",
- OP_u32: "u32",
- OP_u64: "u64",
- OP_f32: "f32",
- OP_f64: "f64",
- OP_str: "str",
- OP_bin: "bin",
- OP_quote: "quote",
- OP_number: "number",
- OP_eface: "eface",
- OP_iface: "iface",
- OP_byte: "byte",
- OP_text: "text",
- OP_deref: "deref",
- OP_index: "index",
- OP_load: "load",
- OP_save: "save",
- OP_drop: "drop",
- OP_drop_2: "drop_2",
- OP_recurse: "recurse",
- OP_is_nil: "is_nil",
- OP_is_nil_p1: "is_nil_p1",
- OP_is_zero_1: "is_zero_1",
- OP_is_zero_2: "is_zero_2",
- OP_is_zero_4: "is_zero_4",
- OP_is_zero_8: "is_zero_8",
- OP_is_zero_map: "is_zero_map",
- OP_goto: "goto",
- OP_map_iter: "map_iter",
- OP_map_stop: "map_stop",
- OP_map_check_key: "map_check_key",
- OP_map_write_key: "map_write_key",
- OP_map_value_next: "map_value_next",
- OP_slice_len: "slice_len",
- OP_slice_next: "slice_next",
- OP_marshal: "marshal",
- OP_marshal_p: "marshal_p",
- OP_marshal_text: "marshal_text",
- OP_marshal_text_p: "marshal_text_p",
- OP_cond_set: "cond_set",
- OP_cond_testc: "cond_testc",
-}
-
-func (self Op) String() string {
- if ret := OpNames[self]; ret != "" {
- return ret
- } else {
- return "<invalid>"
- }
-}
-
-func OP_int() Op {
- switch _INT_SIZE {
- case 32:
- return OP_i32
- case 64:
- return OP_i64
- default:
- panic("unsupported int size")
- }
-}
-
-func OP_uint() Op {
- switch _INT_SIZE {
- case 32:
- return OP_u32
- case 64:
- return OP_u64
- default:
- panic("unsupported uint size")
- }
-}
-
-func OP_uintptr() Op {
- switch _PTR_SIZE {
- case 32:
- return OP_u32
- case 64:
- return OP_u64
- default:
- panic("unsupported pointer size")
- }
-}
-
-func OP_is_zero_ints() Op {
- switch _INT_SIZE {
- case 32:
- return OP_is_zero_4
- case 64:
- return OP_is_zero_8
- default:
- panic("unsupported integer size")
- }
-}
-
-type Instr struct {
- o Op
- u int // union {op: 8, _: 8, vi: 48}, vi maybe int or len(str)
- p unsafe.Pointer // maybe GoString.Ptr, or *GoType
-}
-
-func NewInsOp(op Op) Instr {
- return Instr{o: op}
-}
-
-func NewInsVi(op Op, vi int) Instr {
- return Instr{o: op, u: vi}
-}
-
-func NewInsVs(op Op, vs string) Instr {
- return Instr{
- o: op,
- u: len(vs),
- p: (*rt.GoString)(unsafe.Pointer(&vs)).Ptr,
- }
-}
-
-func NewInsVt(op Op, vt reflect.Type) Instr {
- return Instr{
- o: op,
- p: unsafe.Pointer(rt.UnpackType(vt)),
- }
-}
-
-type typAndTab struct {
- vt *rt.GoType
- itab *rt.GoItab
-}
-
-func NewInsVtab(op Op, vt reflect.Type, itab *rt.GoItab) Instr {
- return Instr{
- o: op,
- p: unsafe.Pointer(&typAndTab{
- vt: rt.UnpackType(vt),
- itab: itab,
- }),
- }
-}
-
-func NewInsVp(op Op, vt reflect.Type, pv bool) Instr {
- i := 0
- if pv {
- i = 1
- }
- return Instr{
- o: op,
- u: i,
- p: unsafe.Pointer(rt.UnpackType(vt)),
- }
-}
-
-func (self Instr) Op() Op {
- return Op(self.o)
-}
-
-func (self Instr) Vi() int {
- return self.u
-}
-
-func (self Instr) Vf() uint8 {
- return (*rt.GoType)(self.p).KindFlags
-}
-
-func (self Instr) Vs() (v string) {
- (*rt.GoString)(unsafe.Pointer(&v)).Ptr = self.p
- (*rt.GoString)(unsafe.Pointer(&v)).Len = self.Vi()
- return
-}
-
-func (self Instr) Vk() reflect.Kind {
- return (*rt.GoType)(self.p).Kind()
-}
-
-func (self Instr) Vt() reflect.Type {
- return (*rt.GoType)(self.p).Pack()
-}
-
-func (self Instr) Vr() *rt.GoType {
- return (*rt.GoType)(self.p)
-}
-
-func (self Instr) Vp() (vt reflect.Type, pv bool) {
- return (*rt.GoType)(self.p).Pack(), self.u == 1
-}
-
-func (self Instr) Vtab() (vt *rt.GoType, itab *rt.GoItab) {
- tt := (*typAndTab)(self.p)
- return tt.vt, tt.itab
-}
-
-func (self Instr) Vp2() (vt *rt.GoType, pv bool) {
- return (*rt.GoType)(self.p), self.u == 1
-}
-
-func (self Instr) I64() int64 {
- return int64(self.Vi())
-}
-
-func (self Instr) Byte() byte {
- return byte(self.Vi())
-}
-
-func (self Instr) Vlen() int {
- return int((*rt.GoType)(self.p).Size)
-}
-
-func (self Instr) isBranch() bool {
- switch self.Op() {
- case OP_goto:
- fallthrough
- case OP_is_nil:
- fallthrough
- case OP_is_nil_p1:
- fallthrough
- case OP_is_zero_1:
- fallthrough
- case OP_is_zero_2:
- fallthrough
- case OP_is_zero_4:
- fallthrough
- case OP_is_zero_8:
- fallthrough
- case OP_map_check_key:
- fallthrough
- case OP_map_write_key:
- fallthrough
- case OP_slice_next:
- fallthrough
- case OP_cond_testc:
- return true
- default:
- return false
- }
-}
-
-func (self Instr) Disassemble() string {
- switch self.Op() {
- case OP_byte:
- return fmt.Sprintf("%-18s%s", self.Op().String(), strconv.QuoteRune(rune(self.Vi())))
- case OP_text:
- return fmt.Sprintf("%-18s%s", self.Op().String(), strconv.Quote(self.Vs()))
- case OP_index:
- return fmt.Sprintf("%-18s%d", self.Op().String(), self.Vi())
- case OP_recurse:
- fallthrough
- case OP_map_iter:
- return fmt.Sprintf("%-18s%s", self.Op().String(), self.Vt())
- case OP_marshal:
- fallthrough
- case OP_marshal_p:
- fallthrough
- case OP_marshal_text:
- fallthrough
- case OP_marshal_text_p:
- vt, _ := self.Vtab()
- return fmt.Sprintf("%-18s%s", self.Op().String(), vt.Pack())
- case OP_goto:
- fallthrough
- case OP_is_nil:
- fallthrough
- case OP_is_nil_p1:
- fallthrough
- case OP_is_zero_1:
- fallthrough
- case OP_is_zero_2:
- fallthrough
- case OP_is_zero_4:
- fallthrough
- case OP_is_zero_8:
- fallthrough
- case OP_is_zero_map:
- fallthrough
- case OP_cond_testc:
- fallthrough
- case OP_map_check_key:
- fallthrough
- case OP_map_write_key:
- return fmt.Sprintf("%-18sL_%d", self.Op().String(), self.Vi())
- case OP_slice_next:
- return fmt.Sprintf("%-18sL_%d, %s", self.Op().String(), self.Vi(), self.Vt())
- default:
- return fmt.Sprintf("%#v", self)
- }
-}
-
-type (
- Program []Instr
-)
-
-func (self Program) PC() int {
- return len(self)
-}
-
-func (self Program) Tag(n int) {
- if n >= vars.MaxStack {
- panic("type nesting too deep")
- }
-}
-
-func (self Program) Pin(i int) {
- v := &self[i]
- v.u = self.PC()
-}
-
-func (self Program) Rel(v []int) {
- for _, i := range v {
- self.Pin(i)
- }
-}
-
-func (self *Program) Add(op Op) {
- *self = append(*self, NewInsOp(op))
-}
-
-func (self *Program) Key(op Op) {
- *self = append(*self,
- NewInsVi(OP_byte, '"'),
- NewInsOp(op),
- NewInsVi(OP_byte, '"'),
- )
-}
-
-func (self *Program) Int(op Op, vi int) {
- *self = append(*self, NewInsVi(op, vi))
-}
-
-func (self *Program) Str(op Op, vs string) {
- *self = append(*self, NewInsVs(op, vs))
-}
-
-func (self *Program) Rtt(op Op, vt reflect.Type) {
- *self = append(*self, NewInsVt(op, vt))
-}
-
-func (self *Program) Vp(op Op, vt reflect.Type, pv bool) {
- *self = append(*self, NewInsVp(op, vt, pv))
-}
-
-func (self *Program) Vtab(op Op, vt reflect.Type, itab *rt.GoItab) {
- *self = append(*self, NewInsVtab(op, vt, itab))
-}
-
-func (self Program) Disassemble() string {
- nb := len(self)
- tab := make([]bool, nb+1)
- ret := make([]string, 0, nb+1)
-
- /* prescan to get all the labels */
- for _, ins := range self {
- if ins.isBranch() {
- tab[ins.Vi()] = true
- }
- }
-
- /* disassemble each instruction */
- for i, ins := range self {
- if !tab[i] {
- ret = append(ret, "\t"+ins.Disassemble())
- } else {
- ret = append(ret, fmt.Sprintf("L_%d:\n\t%s", i, ins.Disassemble()))
- }
- }
-
- /* add the last label, if needed */
- if tab[nb] {
- ret = append(ret, fmt.Sprintf("L_%d:", nb))
- }
-
- /* add an "end" indicator, and join all the strings */
- return strings.Join(append(ret, "\tend"), "\n")
-}
generated by cgit v1.2.3 (git 2.46.0) at 2025-08-01 04:27:53 +0000