Source file src/github.com/bytedance/sonic/internal/decoder/generic_regabi_amd64.go

Documentation: github.com/bytedance/sonic/internal/decoder

     1  // +build go1.17,!go1.23
     2  
     3  /*
     4   * Copyright 2021 ByteDance Inc.
     5   *
     6   * Licensed under the Apache License, Version 2.0 (the "License");
     7   * you may not use this file except in compliance with the License.
     8   * You may obtain a copy of the License at
     9   *
    10   *     http://www.apache.org/licenses/LICENSE-2.0
    11   *
    12   * Unless required by applicable law or agreed to in writing, software
    13   * distributed under the License is distributed on an "AS IS" BASIS,
    14   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    15   * See the License for the specific language governing permissions and
    16   * limitations under the License.
    17   */
    18  
    19  package decoder
    20  
    21  import (
    22      `encoding/json`
    23      `fmt`
    24      `reflect`
    25  
    26      `github.com/bytedance/sonic/internal/jit`
    27      `github.com/bytedance/sonic/internal/native`
    28      `github.com/bytedance/sonic/internal/native/types`
    29      `github.com/twitchyliquid64/golang-asm/obj`
    30  )
    31  
    32  /** Crucial Registers:
    33   *
    34   *      ST(R13) && 0(SP) : ro, decoder stack
    35   *      DF(AX)  : ro, decoder flags
    36   *      EP(BX) : wo, error pointer
    37   *      IP(R10) : ro, input pointer
    38   *      IL(R12) : ro, input length
    39   *      IC(R11) : rw, input cursor
    40   *      VP(R15) : ro, value pointer (to an interface{})
    41   */
    42  
    43  const (
    44      _VD_args   = 8      // 8 bytes  for passing arguments to this functions
    45      _VD_fargs  = 64     // 64 bytes for passing arguments to other Go functions
    46      _VD_saves  = 48     // 48 bytes for saving the registers before CALL instructions
    47      _VD_locals = 96     // 96 bytes for local variables
    48  )
    49  
    50  const (
    51      _VD_offs = _VD_fargs + _VD_saves + _VD_locals
    52      _VD_size = _VD_offs + 8     // 8 bytes for the parent frame pointer
    53  )
    54  
    55  var (
    56      _VAR_ss = _VAR_ss_Vt
    57      _VAR_df = jit.Ptr(_SP, _VD_fargs + _VD_saves)
    58  )
    59  
    60  var (
    61      _VAR_ss_Vt = jit.Ptr(_SP, _VD_fargs + _VD_saves + 8)
    62      _VAR_ss_Dv = jit.Ptr(_SP, _VD_fargs + _VD_saves + 16)
    63      _VAR_ss_Iv = jit.Ptr(_SP, _VD_fargs + _VD_saves + 24)
    64      _VAR_ss_Ep = jit.Ptr(_SP, _VD_fargs + _VD_saves + 32)
    65      _VAR_ss_Db = jit.Ptr(_SP, _VD_fargs + _VD_saves + 40)
    66      _VAR_ss_Dc = jit.Ptr(_SP, _VD_fargs + _VD_saves + 48)
    67  )
    68  
    69  var (
    70      _VAR_R9 = jit.Ptr(_SP, _VD_fargs + _VD_saves + 56)
    71  )
    72  type _ValueDecoder struct {
    73      jit.BaseAssembler
    74  }
    75  
    76  var (
    77      _VAR_cs_LR = jit.Ptr(_SP, _VD_fargs + _VD_saves + 64)
    78      _VAR_cs_p = jit.Ptr(_SP, _VD_fargs + _VD_saves + 72)
    79      _VAR_cs_n = jit.Ptr(_SP, _VD_fargs + _VD_saves + 80)
    80      _VAR_cs_d = jit.Ptr(_SP, _VD_fargs + _VD_saves + 88)
    81  )
    82  
    83  func (self *_ValueDecoder) build() uintptr {
    84      self.Init(self.compile)
    85      return *(*uintptr)(self.Load("decode_value", _VD_size, _VD_args, argPtrs_generic, localPtrs_generic))
    86  }
    87  
    88  /** Function Calling Helpers **/
    89  
    90  func (self *_ValueDecoder) save(r ...obj.Addr) {
    91      for i, v := range r {
    92          if i > _VD_saves / 8 - 1 {
    93              panic("too many registers to save")
    94          } else {
    95              self.Emit("MOVQ", v, jit.Ptr(_SP, _VD_fargs + int64(i) * 8))
    96          }
    97      }
    98  }
    99  
   100  func (self *_ValueDecoder) load(r ...obj.Addr) {
   101      for i, v := range r {
   102          if i > _VD_saves / 8 - 1 {
   103              panic("too many registers to load")
   104          } else {
   105              self.Emit("MOVQ", jit.Ptr(_SP, _VD_fargs + int64(i) * 8), v)
   106          }
   107      }
   108  }
   109  
   110  func (self *_ValueDecoder) call(fn obj.Addr) {
   111      self.Emit("MOVQ", fn, _R9)  // MOVQ ${fn}, AX
   112      self.Rjmp("CALL", _R9)      // CALL AX
   113  }
   114  
   115  func (self *_ValueDecoder) call_go(fn obj.Addr) {
   116      self.save(_REG_go...)   // SAVE $REG_go
   117      self.call(fn)           // CALL ${fn}
   118      self.load(_REG_go...)   // LOAD $REG_go
   119  }
   120  
   121  func (self *_ValueDecoder) callc(fn obj.Addr) {
   122      self.save(_IP)  
   123      self.call(fn)
   124      self.load(_IP)  
   125  }
   126  
   127  func (self *_ValueDecoder) call_c(fn obj.Addr) {
   128      self.Emit("XCHGQ", _IC, _BX)
   129      self.callc(fn)
   130      self.Emit("XCHGQ", _IC, _BX)
   131  }
   132  
   133  /** Decoder Assembler **/
   134  
   135  const (
   136      _S_val = iota + 1
   137      _S_arr
   138      _S_arr_0
   139      _S_obj
   140      _S_obj_0
   141      _S_obj_delim
   142      _S_obj_sep
   143  )
   144  
   145  const (
   146      _S_omask_key = (1 << _S_obj_0) | (1 << _S_obj_sep)
   147      _S_omask_end = (1 << _S_obj_0) | (1 << _S_obj)
   148      _S_vmask = (1 << _S_val) | (1 << _S_arr_0)
   149  )
   150  
   151  const (
   152      _A_init_len = 1
   153      _A_init_cap = 16
   154  )
   155  
   156  const (
   157      _ST_Sp = 0
   158      _ST_Vt = _PtrBytes
   159      _ST_Vp = _PtrBytes * (types.MAX_RECURSE + 1)
   160  )
   161  
   162  var (
   163      _V_true  = jit.Imm(int64(pbool(true)))
   164      _V_false = jit.Imm(int64(pbool(false)))
   165      _F_value = jit.Imm(int64(native.S_value))
   166  )
   167  
   168  var (
   169      _V_max     = jit.Imm(int64(types.V_MAX))
   170      _E_eof     = jit.Imm(int64(types.ERR_EOF))
   171      _E_invalid = jit.Imm(int64(types.ERR_INVALID_CHAR))
   172      _E_recurse = jit.Imm(int64(types.ERR_RECURSE_EXCEED_MAX))
   173  )
   174  
   175  var (
   176      _F_convTslice    = jit.Func(convTslice)
   177      _F_convTstring   = jit.Func(convTstring)
   178      _F_invalid_vtype = jit.Func(invalid_vtype)
   179  )
   180  
   181  var (
   182      _T_map     = jit.Type(reflect.TypeOf((map[string]interface{})(nil)))
   183      _T_bool    = jit.Type(reflect.TypeOf(false))
   184      _T_int64   = jit.Type(reflect.TypeOf(int64(0)))
   185      _T_eface   = jit.Type(reflect.TypeOf((*interface{})(nil)).Elem())
   186      _T_slice   = jit.Type(reflect.TypeOf(([]interface{})(nil)))
   187      _T_string  = jit.Type(reflect.TypeOf(""))
   188      _T_number  = jit.Type(reflect.TypeOf(json.Number("")))
   189      _T_float64 = jit.Type(reflect.TypeOf(float64(0)))
   190  )
   191  
   192  var _R_tab = map[int]string {
   193      '[': "_decode_V_ARRAY",
   194      '{': "_decode_V_OBJECT",
   195      ':': "_decode_V_KEY_SEP",
   196      ',': "_decode_V_ELEM_SEP",
   197      ']': "_decode_V_ARRAY_END",
   198      '}': "_decode_V_OBJECT_END",
   199  }
   200  
   201  func (self *_ValueDecoder) compile() {
   202      self.Emit("SUBQ", jit.Imm(_VD_size), _SP)       // SUBQ $_VD_size, SP
   203      self.Emit("MOVQ", _BP, jit.Ptr(_SP, _VD_offs))  // MOVQ BP, _VD_offs(SP)
   204      self.Emit("LEAQ", jit.Ptr(_SP, _VD_offs), _BP)  // LEAQ _VD_offs(SP), BP
   205  
   206      /* initialize the state machine */
   207      self.Emit("XORL", _CX, _CX)                                 // XORL CX, CX
   208      self.Emit("MOVQ", _DF, _VAR_df)                             // MOVQ DF, df
   209      /* initialize digital buffer first */
   210      self.Emit("MOVQ", jit.Imm(_MaxDigitNums), _VAR_ss_Dc)       // MOVQ $_MaxDigitNums, ss.Dcap
   211      self.Emit("LEAQ", jit.Ptr(_ST, _DbufOffset), _AX)           // LEAQ _DbufOffset(ST), AX
   212      self.Emit("MOVQ", _AX, _VAR_ss_Db)                          // MOVQ AX, ss.Dbuf
   213      /* add ST offset */
   214      self.Emit("ADDQ", jit.Imm(_FsmOffset), _ST)                 // ADDQ _FsmOffset, _ST
   215      self.Emit("MOVQ", _CX, jit.Ptr(_ST, _ST_Sp))                // MOVQ CX, ST.Sp
   216      self.WriteRecNotAX(0, _VP, jit.Ptr(_ST, _ST_Vp), false)                // MOVQ VP, ST.Vp[0]
   217      self.Emit("MOVQ", jit.Imm(_S_val), jit.Ptr(_ST, _ST_Vt))    // MOVQ _S_val, ST.Vt[0]
   218      self.Sjmp("JMP" , "_next")                                  // JMP  _next
   219  
   220      /* set the value from previous round */
   221      self.Link("_set_value")                                 // _set_value:
   222      self.Emit("MOVL" , jit.Imm(_S_vmask), _DX)              // MOVL  _S_vmask, DX
   223      self.Emit("MOVQ" , jit.Ptr(_ST, _ST_Sp), _CX)           // MOVQ  ST.Sp, CX
   224      self.Emit("MOVQ" , jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)   // MOVQ  ST.Vt[CX], AX
   225      self.Emit("BTQ"  , _AX, _DX)                            // BTQ   AX, DX
   226      self.Sjmp("JNC"  , "_vtype_error")                      // JNC   _vtype_error
   227      self.Emit("XORL" , _SI, _SI)                            // XORL  SI, SI
   228      self.Emit("SUBQ" , jit.Imm(1), jit.Ptr(_ST, _ST_Sp))    // SUBQ  $1, ST.Sp
   229      self.Emit("XCHGQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)   // XCHGQ ST.Vp[CX], SI
   230      self.Emit("MOVQ" , _R8, jit.Ptr(_SI, 0))                // MOVQ  R8, (SI)
   231      self.WriteRecNotAX(1, _R9, jit.Ptr(_SI, 8), false)           // MOVQ  R9, 8(SI)
   232  
   233      /* check for value stack */
   234      self.Link("_next")                              // _next:
   235      self.Emit("MOVQ" , jit.Ptr(_ST, _ST_Sp), _AX)   // MOVQ  ST.Sp, AX
   236      self.Emit("TESTQ", _AX, _AX)                    // TESTQ AX, AX
   237      self.Sjmp("JS"   , "_return")                   // JS    _return
   238  
   239      /* fast path: test up to 4 characters manually */
   240      self.Emit("CMPQ"   , _IC, _IL)                      // CMPQ    IC, IL
   241      self.Sjmp("JAE"    , "_decode_V_EOF")               // JAE     _decode_V_EOF
   242      self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX)  // MOVBQZX (IP)(IC), AX
   243      self.Emit("MOVQ"   , jit.Imm(_BM_space), _DX)       // MOVQ    _BM_space, DX
   244      self.Emit("CMPQ"   , _AX, jit.Imm(' '))             // CMPQ    AX, $' '
   245      self.Sjmp("JA"     , "_decode_fast")                // JA      _decode_fast
   246      self.Emit("BTQ"    , _AX, _DX)                      // BTQ     _AX, _DX
   247      self.Sjmp("JNC"    , "_decode_fast")                // JNC     _decode_fast
   248      self.Emit("ADDQ"   , jit.Imm(1), _IC)               // ADDQ    $1, IC
   249  
   250      /* at least 1 to 3 spaces */
   251      for i := 0; i < 3; i++ {
   252          self.Emit("CMPQ"   , _IC, _IL)                      // CMPQ    IC, IL
   253          self.Sjmp("JAE"    , "_decode_V_EOF")               // JAE     _decode_V_EOF
   254          self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX)  // MOVBQZX (IP)(IC), AX
   255          self.Emit("CMPQ"   , _AX, jit.Imm(' '))             // CMPQ    AX, $' '
   256          self.Sjmp("JA"     , "_decode_fast")                // JA      _decode_fast
   257          self.Emit("BTQ"    , _AX, _DX)                      // BTQ     _AX, _DX
   258          self.Sjmp("JNC"    , "_decode_fast")                // JNC     _decode_fast
   259          self.Emit("ADDQ"   , jit.Imm(1), _IC)               // ADDQ    $1, IC
   260      }
   261  
   262      /* at least 4 spaces */
   263      self.Emit("CMPQ"   , _IC, _IL)                      // CMPQ    IC, IL
   264      self.Sjmp("JAE"    , "_decode_V_EOF")               // JAE     _decode_V_EOF
   265      self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX)  // MOVBQZX (IP)(IC), AX
   266  
   267      /* fast path: use lookup table to select decoder */
   268      self.Link("_decode_fast")                           // _decode_fast:
   269      self.Byte(0x48, 0x8d, 0x3d)                         // LEAQ    ?(PC), DI
   270      self.Sref("_decode_tab", 4)                         // ....    &_decode_tab
   271      self.Emit("MOVLQSX", jit.Sib(_DI, _AX, 4, 0), _AX)  // MOVLQSX (DI)(AX*4), AX
   272      self.Emit("TESTQ"  , _AX, _AX)                      // TESTQ   AX, AX
   273      self.Sjmp("JZ"     , "_decode_native")              // JZ      _decode_native
   274      self.Emit("ADDQ"   , jit.Imm(1), _IC)               // ADDQ    $1, IC
   275      self.Emit("ADDQ"   , _DI, _AX)                      // ADDQ    DI, AX
   276      self.Rjmp("JMP"    , _AX)                           // JMP     AX
   277  
   278      /* decode with native decoder */
   279      self.Link("_decode_native")         // _decode_native:
   280      self.Emit("MOVQ", _IP, _DI)         // MOVQ IP, DI
   281      self.Emit("MOVQ", _IL, _SI)         // MOVQ IL, SI
   282      self.Emit("MOVQ", _IC, _DX)         // MOVQ IC, DX
   283      self.Emit("LEAQ", _VAR_ss, _CX)     // LEAQ ss, CX
   284      self.Emit("MOVQ", _VAR_df, _R8)     // MOVQ $df, R8
   285      self.Emit("BTSQ", jit.Imm(_F_allow_control), _R8)  // ANDQ $1<<_F_allow_control, R8
   286      self.callc(_F_value)                // CALL value
   287      self.Emit("MOVQ", _AX, _IC)         // MOVQ AX, IC
   288  
   289      /* check for errors */
   290      self.Emit("MOVQ" , _VAR_ss_Vt, _AX)     // MOVQ  ss.Vt, AX
   291      self.Emit("TESTQ", _AX, _AX)            // TESTQ AX, AX
   292      self.Sjmp("JS"   , "_parsing_error")       
   293      self.Sjmp("JZ"   , "_invalid_vtype")    // JZ    _invalid_vtype
   294      self.Emit("CMPQ" , _AX, _V_max)         // CMPQ  AX, _V_max
   295      self.Sjmp("JA"   , "_invalid_vtype")    // JA    _invalid_vtype
   296  
   297      /* jump table selector */
   298      self.Byte(0x48, 0x8d, 0x3d)                             // LEAQ    ?(PC), DI
   299      self.Sref("_switch_table", 4)                           // ....    &_switch_table
   300      self.Emit("MOVLQSX", jit.Sib(_DI, _AX, 4, -4), _AX)     // MOVLQSX -4(DI)(AX*4), AX
   301      self.Emit("ADDQ"   , _DI, _AX)                          // ADDQ    DI, AX
   302      self.Rjmp("JMP"    , _AX)                               // JMP     AX
   303  
   304      /** V_EOF **/
   305      self.Link("_decode_V_EOF")          // _decode_V_EOF:
   306      self.Emit("MOVL", _E_eof, _EP)      // MOVL _E_eof, EP
   307      self.Sjmp("JMP" , "_error")         // JMP  _error
   308  
   309      /** V_NULL **/
   310      self.Link("_decode_V_NULL")                 // _decode_V_NULL:
   311      self.Emit("XORL", _R8, _R8)                 // XORL R8, R8
   312      self.Emit("XORL", _R9, _R9)                 // XORL R9, R9
   313      self.Emit("LEAQ", jit.Ptr(_IC, -4), _DI)    // LEAQ -4(IC), DI
   314      self.Sjmp("JMP" , "_set_value")             // JMP  _set_value
   315  
   316      /** V_TRUE **/
   317      self.Link("_decode_V_TRUE")                 // _decode_V_TRUE:
   318      self.Emit("MOVQ", _T_bool, _R8)             // MOVQ _T_bool, R8
   319      // TODO: maybe modified by users?
   320      self.Emit("MOVQ", _V_true, _R9)             // MOVQ _V_true, R9 
   321      self.Emit("LEAQ", jit.Ptr(_IC, -4), _DI)    // LEAQ -4(IC), DI
   322      self.Sjmp("JMP" , "_set_value")             // JMP  _set_value
   323  
   324      /** V_FALSE **/
   325      self.Link("_decode_V_FALSE")                // _decode_V_FALSE:
   326      self.Emit("MOVQ", _T_bool, _R8)             // MOVQ _T_bool, R8
   327      self.Emit("MOVQ", _V_false, _R9)            // MOVQ _V_false, R9
   328      self.Emit("LEAQ", jit.Ptr(_IC, -5), _DI)    // LEAQ -5(IC), DI
   329      self.Sjmp("JMP" , "_set_value")             // JMP  _set_value
   330  
   331      /** V_ARRAY **/
   332      self.Link("_decode_V_ARRAY")                            // _decode_V_ARRAY
   333      self.Emit("MOVL", jit.Imm(_S_vmask), _DX)               // MOVL _S_vmask, DX
   334      self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
   335      self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)    // MOVQ ST.Vt[CX], AX
   336      self.Emit("BTQ" , _AX, _DX)                             // BTQ  AX, DX
   337      self.Sjmp("JNC" , "_invalid_char")                      // JNC  _invalid_char
   338  
   339      /* create a new array */
   340      self.Emit("MOVQ", _T_eface, _AX)                            // MOVQ    _T_eface, AX
   341      self.Emit("MOVQ", jit.Imm(_A_init_len), _BX)                // MOVQ    _A_init_len, BX
   342      self.Emit("MOVQ", jit.Imm(_A_init_cap), _CX)                // MOVQ    _A_init_cap, CX
   343      self.call_go(_F_makeslice)                                  // CALL_GO runtime.makeslice
   344  
   345      /* pack into an interface */
   346      self.Emit("MOVQ", jit.Imm(_A_init_len), _BX)                // MOVQ    _A_init_len, BX
   347      self.Emit("MOVQ", jit.Imm(_A_init_cap), _CX)                // MOVQ    _A_init_cap, CX
   348      self.call_go(_F_convTslice)                                 // CALL_GO runtime.convTslice
   349      self.Emit("MOVQ", _AX, _R8)                                 // MOVQ    AX, R8
   350  
   351      /* replace current state with an array */
   352      self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                        // MOVQ ST.Sp, CX
   353      self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)                // MOVQ ST.Vp[CX], SI
   354      self.Emit("MOVQ", jit.Imm(_S_arr), jit.Sib(_ST, _CX, 8, _ST_Vt))    // MOVQ _S_arr, ST.Vt[CX]
   355      self.Emit("MOVQ", _T_slice, _AX)                                    // MOVQ _T_slice, AX
   356      self.Emit("MOVQ", _AX, jit.Ptr(_SI, 0))                             // MOVQ AX, (SI)
   357      self.WriteRecNotAX(2, _R8, jit.Ptr(_SI, 8), false)                  // MOVQ R8, 8(SI)
   358  
   359      /* add a new slot for the first element */
   360      self.Emit("ADDQ", jit.Imm(1), _CX)                                  // ADDQ $1, CX
   361      self.Emit("CMPQ", _CX, jit.Imm(types.MAX_RECURSE))                  // CMPQ CX, ${types.MAX_RECURSE}
   362      self.Sjmp("JAE"  , "_stack_overflow")                                // JA   _stack_overflow
   363      self.Emit("MOVQ", jit.Ptr(_R8, 0), _AX)                             // MOVQ (R8), AX
   364      self.Emit("MOVQ", _CX, jit.Ptr(_ST, _ST_Sp))                        // MOVQ CX, ST.Sp
   365      self.WritePtrAX(3, jit.Sib(_ST, _CX, 8, _ST_Vp), false)             // MOVQ AX, ST.Vp[CX]
   366      self.Emit("MOVQ", jit.Imm(_S_arr_0), jit.Sib(_ST, _CX, 8, _ST_Vt))  // MOVQ _S_arr_0, ST.Vt[CX]
   367      self.Sjmp("JMP" , "_next")                                          // JMP  _next
   368  
   369      /** V_OBJECT **/
   370      self.Link("_decode_V_OBJECT")                                       // _decode_V_OBJECT:
   371      self.Emit("MOVL", jit.Imm(_S_vmask), _DX)                           // MOVL    _S_vmask, DX
   372      self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                        // MOVQ    ST.Sp, CX
   373      self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)                // MOVQ    ST.Vt[CX], AX
   374      self.Emit("BTQ" , _AX, _DX)                                         // BTQ     AX, DX
   375      self.Sjmp("JNC" , "_invalid_char")                                  // JNC     _invalid_char
   376      self.call_go(_F_makemap_small)                                      // CALL_GO runtime.makemap_small
   377      self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                        // MOVQ    ST.Sp, CX
   378      self.Emit("MOVQ", jit.Imm(_S_obj_0), jit.Sib(_ST, _CX, 8, _ST_Vt))    // MOVQ    _S_obj_0, ST.Vt[CX]
   379      self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)                // MOVQ    ST.Vp[CX], SI
   380      self.Emit("MOVQ", _T_map, _DX)                                      // MOVQ    _T_map, DX
   381      self.Emit("MOVQ", _DX, jit.Ptr(_SI, 0))                             // MOVQ    DX, (SI)
   382      self.WritePtrAX(4, jit.Ptr(_SI, 8), false)                          // MOVQ    AX, 8(SI)
   383      self.Sjmp("JMP" , "_next")                                          // JMP     _next
   384  
   385      /** V_STRING **/
   386      self.Link("_decode_V_STRING")       // _decode_V_STRING:
   387      self.Emit("MOVQ", _VAR_ss_Iv, _CX)  // MOVQ ss.Iv, CX
   388      self.Emit("MOVQ", _IC, _AX)         // MOVQ IC, AX
   389      self.Emit("SUBQ", _CX, _AX)         // SUBQ CX, AX
   390  
   391      /* check for escapes */
   392      self.Emit("CMPQ", _VAR_ss_Ep, jit.Imm(-1))          // CMPQ ss.Ep, $-1
   393      self.Sjmp("JNE" , "_unquote")                       // JNE  _unquote
   394      self.Emit("SUBQ", jit.Imm(1), _AX)                  // SUBQ $1, AX
   395      self.Emit("LEAQ", jit.Sib(_IP, _CX, 1, 0), _R8)     // LEAQ (IP)(CX), R8
   396      self.Byte(0x48, 0x8d, 0x3d)                         // LEAQ (PC), DI
   397      self.Sref("_copy_string_end", 4)
   398      self.Emit("BTQ", jit.Imm(_F_copy_string), _VAR_df)
   399      self.Sjmp("JC", "copy_string")
   400      self.Link("_copy_string_end")                                 
   401      self.Emit("XORL", _DX, _DX)   
   402  
   403      /* strings with no escape sequences */
   404      self.Link("_noescape")                                  // _noescape:
   405      self.Emit("MOVL", jit.Imm(_S_omask_key), _DI)               // MOVL _S_omask, DI
   406      self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
   407      self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _SI)    // MOVQ ST.Vt[CX], SI
   408      self.Emit("BTQ" , _SI, _DI)                             // BTQ  SI, DI
   409      self.Sjmp("JC"  , "_object_key")                        // JC   _object_key
   410  
   411      /* check for pre-packed strings, avoid 1 allocation */
   412      self.Emit("TESTQ", _DX, _DX)                // TESTQ   DX, DX
   413      self.Sjmp("JNZ"  , "_packed_str")           // JNZ     _packed_str
   414      self.Emit("MOVQ" , _AX, _BX)                // MOVQ    AX, BX
   415      self.Emit("MOVQ" , _R8, _AX)                // MOVQ    R8, AX
   416      self.call_go(_F_convTstring)                // CALL_GO runtime.convTstring
   417      self.Emit("MOVQ" , _AX, _R9)                // MOVQ    AX, R9
   418  
   419      /* packed string already in R9 */
   420      self.Link("_packed_str")            // _packed_str:
   421      self.Emit("MOVQ", _T_string, _R8)   // MOVQ _T_string, R8
   422      self.Emit("MOVQ", _VAR_ss_Iv, _DI)  // MOVQ ss.Iv, DI
   423      self.Emit("SUBQ", jit.Imm(1), _DI)  // SUBQ $1, DI
   424      self.Sjmp("JMP" , "_set_value")     // JMP  _set_value
   425  
   426      /* the string is an object key, get the map */
   427      self.Link("_object_key")
   428      self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
   429      self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)    // MOVQ ST.Vp[CX], SI
   430      self.Emit("MOVQ", jit.Ptr(_SI, 8), _SI)                 // MOVQ 8(SI), SI
   431  
   432      /* add a new delimiter */
   433      self.Emit("ADDQ", jit.Imm(1), _CX)                                      // ADDQ $1, CX
   434      self.Emit("CMPQ", _CX, jit.Imm(types.MAX_RECURSE))                      // CMPQ CX, ${types.MAX_RECURSE}
   435      self.Sjmp("JAE"  , "_stack_overflow")                                    // JA   _stack_overflow
   436      self.Emit("MOVQ", _CX, jit.Ptr(_ST, _ST_Sp))                            // MOVQ CX, ST.Sp
   437      self.Emit("MOVQ", jit.Imm(_S_obj_delim), jit.Sib(_ST, _CX, 8, _ST_Vt))  // MOVQ _S_obj_delim, ST.Vt[CX]
   438  
   439      /* add a new slot int the map */
   440      self.Emit("MOVQ", _AX, _DI)                         // MOVQ    AX, DI
   441      self.Emit("MOVQ", _T_map, _AX)                      // MOVQ    _T_map, AX
   442      self.Emit("MOVQ", _SI, _BX)                         // MOVQ    SI, BX
   443      self.Emit("MOVQ", _R8, _CX)                         // MOVQ    R9, CX
   444      self.call_go(_F_mapassign_faststr)                  // CALL_GO runtime.mapassign_faststr
   445  
   446      /* add to the pointer stack */
   447      self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                 // MOVQ ST.Sp, CX
   448      self.WritePtrAX(6, jit.Sib(_ST, _CX, 8, _ST_Vp), false)    // MOVQ AX, ST.Vp[CX]
   449      self.Sjmp("JMP" , "_next")                                   // JMP  _next
   450  
   451      /* allocate memory to store the string header and unquoted result */
   452      self.Link("_unquote")                               // _unquote:
   453      self.Emit("ADDQ", jit.Imm(15), _AX)                 // ADDQ    $15, AX
   454      self.Emit("MOVQ", _T_byte, _BX)                     // MOVQ    _T_byte, BX
   455      self.Emit("MOVB", jit.Imm(0), _CX)                  // MOVB    $0, CX
   456      self.call_go(_F_mallocgc)                           // CALL_GO runtime.mallocgc
   457      self.Emit("MOVQ", _AX, _R9)                         // MOVQ    AX, R9
   458  
   459      /* prepare the unquoting parameters */
   460      self.Emit("MOVQ" , _VAR_ss_Iv, _CX)                         // MOVQ  ss.Iv, CX
   461      self.Emit("LEAQ" , jit.Sib(_IP, _CX, 1, 0), _DI)            // LEAQ  (IP)(CX), DI
   462      self.Emit("NEGQ" , _CX)                                     // NEGQ  CX
   463      self.Emit("LEAQ" , jit.Sib(_IC, _CX, 1, -1), _SI)           // LEAQ  -1(IC)(CX), SI
   464      self.Emit("LEAQ" , jit.Ptr(_R9, 16), _DX)                   // LEAQ  16(R8), DX
   465      self.Emit("LEAQ" , _VAR_ss_Ep, _CX)                         // LEAQ  ss.Ep, CX
   466      self.Emit("XORL" , _R8, _R8)                                // XORL  R8, R8
   467      self.Emit("BTQ"  , jit.Imm(_F_disable_urc), _VAR_df)        // BTQ   ${_F_disable_urc}, fv
   468      self.Emit("SETCC", _R8)                                     // SETCC R8
   469      self.Emit("SHLQ" , jit.Imm(types.B_UNICODE_REPLACE), _R8)   // SHLQ  ${types.B_UNICODE_REPLACE}, R8
   470  
   471      /* unquote the string, with R9 been preserved */
   472      self.Emit("MOVQ", _R9, _VAR_R9)             // SAVE R9
   473      self.call_c(_F_unquote)                     // CALL unquote
   474      self.Emit("MOVQ", _VAR_R9, _R9)             // LOAD R9
   475  
   476      /* check for errors */
   477      self.Emit("TESTQ", _AX, _AX)                // TESTQ AX, AX
   478      self.Sjmp("JS"   , "_unquote_error")        // JS    _unquote_error
   479      self.Emit("MOVL" , jit.Imm(1), _DX)         // MOVL  $1, DX
   480      self.Emit("LEAQ" , jit.Ptr(_R9, 16), _R8)   // ADDQ  $16, R8
   481      self.Emit("MOVQ" , _R8, jit.Ptr(_R9, 0))    // MOVQ  R8, (R9)
   482      self.Emit("MOVQ" , _AX, jit.Ptr(_R9, 8))    // MOVQ  AX, 8(R9)
   483      self.Sjmp("JMP"  , "_noescape")             // JMP   _noescape
   484  
   485      /** V_DOUBLE **/
   486      self.Link("_decode_V_DOUBLE")                           // _decode_V_DOUBLE:
   487      self.Emit("BTQ"  , jit.Imm(_F_use_number), _VAR_df)     // BTQ     _F_use_number, df
   488      self.Sjmp("JC"   , "_use_number")                       // JC      _use_number
   489      self.Emit("MOVSD", _VAR_ss_Dv, _X0)                     // MOVSD   ss.Dv, X0
   490      self.Sjmp("JMP"  , "_use_float64")                      // JMP     _use_float64
   491  
   492      /** V_INTEGER **/
   493      self.Link("_decode_V_INTEGER")                          // _decode_V_INTEGER:
   494      self.Emit("BTQ"     , jit.Imm(_F_use_number), _VAR_df)  // BTQ      _F_use_number, df
   495      self.Sjmp("JC"      , "_use_number")                    // JC       _use_number
   496      self.Emit("BTQ"     , jit.Imm(_F_use_int64), _VAR_df)   // BTQ      _F_use_int64, df
   497      self.Sjmp("JC"      , "_use_int64")                     // JC       _use_int64
   498      //TODO: use ss.Dv directly
   499      self.Emit("MOVSD", _VAR_ss_Dv, _X0)                  // MOVSD   ss.Dv, X0
   500  
   501      /* represent numbers as `float64` */
   502      self.Link("_use_float64")                   // _use_float64:
   503      self.Emit("MOVQ" , _X0, _AX)                // MOVQ   X0, AX
   504      self.call_go(_F_convT64)                    // CALL_GO runtime.convT64
   505      self.Emit("MOVQ" , _T_float64, _R8)         // MOVQ    _T_float64, R8
   506      self.Emit("MOVQ" , _AX, _R9)                // MOVQ    AX, R9
   507      self.Emit("MOVQ" , _VAR_ss_Ep, _DI)         // MOVQ    ss.Ep, DI
   508      self.Sjmp("JMP"  , "_set_value")            // JMP     _set_value
   509  
   510      /* represent numbers as `json.Number` */
   511      self.Link("_use_number")                            // _use_number
   512      self.Emit("MOVQ", _VAR_ss_Ep, _AX)                  // MOVQ    ss.Ep, AX
   513      self.Emit("LEAQ", jit.Sib(_IP, _AX, 1, 0), _SI)     // LEAQ    (IP)(AX), SI
   514      self.Emit("MOVQ", _IC, _CX)                         // MOVQ    IC, CX
   515      self.Emit("SUBQ", _AX, _CX)                         // SUBQ    AX, CX
   516      self.Emit("MOVQ", _SI, _AX)                         // MOVQ    SI, AX
   517      self.Emit("MOVQ", _CX, _BX)                         // MOVQ    CX, BX
   518      self.call_go(_F_convTstring)                        // CALL_GO runtime.convTstring
   519      self.Emit("MOVQ", _T_number, _R8)                   // MOVQ    _T_number, R8
   520      self.Emit("MOVQ", _AX, _R9)                         // MOVQ    AX, R9
   521      self.Emit("MOVQ", _VAR_ss_Ep, _DI)                  // MOVQ    ss.Ep, DI
   522      self.Sjmp("JMP" , "_set_value")                     // JMP     _set_value
   523  
   524      /* represent numbers as `int64` */
   525      self.Link("_use_int64")                     // _use_int64:
   526      self.Emit("MOVQ", _VAR_ss_Iv, _AX)          // MOVQ    ss.Iv, AX
   527      self.call_go(_F_convT64)                    // CALL_GO runtime.convT64
   528      self.Emit("MOVQ", _T_int64, _R8)            // MOVQ    _T_int64, R8
   529      self.Emit("MOVQ", _AX, _R9)                 // MOVQ    AX, R9
   530      self.Emit("MOVQ", _VAR_ss_Ep, _DI)          // MOVQ    ss.Ep, DI
   531      self.Sjmp("JMP" , "_set_value")             // JMP     _set_value
   532  
   533      /** V_KEY_SEP **/
   534      self.Link("_decode_V_KEY_SEP")                                          // _decode_V_KEY_SEP:
   535      self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                            // MOVQ ST.Sp, CX
   536      self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)                    // MOVQ ST.Vt[CX], AX
   537      self.Emit("CMPQ", _AX, jit.Imm(_S_obj_delim))                           // CMPQ AX, _S_obj_delim
   538      self.Sjmp("JNE" , "_invalid_char")                                      // JNE  _invalid_char
   539      self.Emit("MOVQ", jit.Imm(_S_val), jit.Sib(_ST, _CX, 8, _ST_Vt))        // MOVQ _S_val, ST.Vt[CX]
   540      self.Emit("MOVQ", jit.Imm(_S_obj), jit.Sib(_ST, _CX, 8, _ST_Vt - 8))    // MOVQ _S_obj, ST.Vt[CX - 1]
   541      self.Sjmp("JMP" , "_next")                                              // JMP  _next
   542  
   543      /** V_ELEM_SEP **/
   544      self.Link("_decode_V_ELEM_SEP")                          // _decode_V_ELEM_SEP:
   545      self.Emit("MOVQ" , jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ     ST.Sp, CX
   546      self.Emit("MOVQ" , jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)    // MOVQ     ST.Vt[CX], AX
   547      self.Emit("CMPQ" , _AX, jit.Imm(_S_arr))      
   548      self.Sjmp("JE"   , "_array_sep")                         // JZ       _next
   549      self.Emit("CMPQ" , _AX, jit.Imm(_S_obj))                 // CMPQ     _AX, _S_arr
   550      self.Sjmp("JNE"  , "_invalid_char")                      // JNE      _invalid_char
   551      self.Emit("MOVQ" , jit.Imm(_S_obj_sep), jit.Sib(_ST, _CX, 8, _ST_Vt))
   552      self.Sjmp("JMP"  , "_next")                              // JMP      _next
   553  
   554      /* arrays */
   555      self.Link("_array_sep")
   556      self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)    // MOVQ ST.Vp[CX], SI
   557      self.Emit("MOVQ", jit.Ptr(_SI, 8), _SI)                 // MOVQ 8(SI), SI
   558      self.Emit("MOVQ", jit.Ptr(_SI, 8), _DX)                 // MOVQ 8(SI), DX
   559      self.Emit("CMPQ", _DX, jit.Ptr(_SI, 16))                // CMPQ DX, 16(SI)
   560      self.Sjmp("JAE" , "_array_more")                        // JAE  _array_more
   561  
   562      /* add a slot for the new element */
   563      self.Link("_array_append")                                          // _array_append:
   564      self.Emit("ADDQ", jit.Imm(1), jit.Ptr(_SI, 8))                      // ADDQ $1, 8(SI)
   565      self.Emit("MOVQ", jit.Ptr(_SI, 0), _SI)                             // MOVQ (SI), SI
   566      self.Emit("ADDQ", jit.Imm(1), _CX)                                  // ADDQ $1, CX
   567      self.Emit("CMPQ", _CX, jit.Imm(types.MAX_RECURSE))                  // CMPQ CX, ${types.MAX_RECURSE}
   568      self.Sjmp("JAE"  , "_stack_overflow")                                // JA   _stack_overflow
   569      self.Emit("SHLQ", jit.Imm(1), _DX)                                  // SHLQ $1, DX
   570      self.Emit("LEAQ", jit.Sib(_SI, _DX, 8, 0), _SI)                     // LEAQ (SI)(DX*8), SI
   571      self.Emit("MOVQ", _CX, jit.Ptr(_ST, _ST_Sp))                        // MOVQ CX, ST.Sp
   572      self.WriteRecNotAX(7 , _SI, jit.Sib(_ST, _CX, 8, _ST_Vp), false)           // MOVQ SI, ST.Vp[CX]
   573      self.Emit("MOVQ", jit.Imm(_S_val), jit.Sib(_ST, _CX, 8, _ST_Vt))    // MOVQ _S_val, ST.Vt[CX}
   574      self.Sjmp("JMP" , "_next")                                          // JMP  _next
   575  
   576      /** V_ARRAY_END **/
   577      self.Link("_decode_V_ARRAY_END")                        // _decode_V_ARRAY_END:
   578      self.Emit("XORL", _DX, _DX)                             // XORL DX, DX
   579      self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
   580      self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)    // MOVQ ST.Vt[CX], AX
   581      self.Emit("CMPQ", _AX, jit.Imm(_S_arr_0))               // CMPQ AX, _S_arr_0
   582      self.Sjmp("JE"  , "_first_item")                        // JE   _first_item
   583      self.Emit("CMPQ", _AX, jit.Imm(_S_arr))                 // CMPQ AX, _S_arr
   584      self.Sjmp("JNE" , "_invalid_char")                      // JNE  _invalid_char
   585      self.Emit("SUBQ", jit.Imm(1), jit.Ptr(_ST, _ST_Sp))     // SUBQ $1, ST.Sp
   586      self.Emit("MOVQ", _DX, jit.Sib(_ST, _CX, 8, _ST_Vp))    // MOVQ DX, ST.Vp[CX]
   587      self.Sjmp("JMP" , "_next")                              // JMP  _next
   588  
   589      /* first element of an array */
   590      self.Link("_first_item")                                    // _first_item:
   591      self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                // MOVQ ST.Sp, CX
   592      self.Emit("SUBQ", jit.Imm(2), jit.Ptr(_ST, _ST_Sp))         // SUBQ $2, ST.Sp
   593      self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp - 8), _SI)    // MOVQ ST.Vp[CX - 1], SI
   594      self.Emit("MOVQ", jit.Ptr(_SI, 8), _SI)                     // MOVQ 8(SI), SI
   595      self.Emit("MOVQ", _DX, jit.Sib(_ST, _CX, 8, _ST_Vp - 8))    // MOVQ DX, ST.Vp[CX - 1]
   596      self.Emit("MOVQ", _DX, jit.Sib(_ST, _CX, 8, _ST_Vp))        // MOVQ DX, ST.Vp[CX]
   597      self.Emit("MOVQ", _DX, jit.Ptr(_SI, 8))                     // MOVQ DX, 8(SI)
   598      self.Sjmp("JMP" , "_next")                                  // JMP  _next
   599  
   600      /** V_OBJECT_END **/
   601      self.Link("_decode_V_OBJECT_END")                       // _decode_V_OBJECT_END:
   602      self.Emit("MOVL", jit.Imm(_S_omask_end), _DI)           // MOVL _S_omask, DI
   603      self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
   604      self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)    // MOVQ ST.Vt[CX], AX
   605      self.Emit("BTQ" , _AX, _DI)                    
   606      self.Sjmp("JNC" , "_invalid_char")                      // JNE  _invalid_char
   607      self.Emit("XORL", _AX, _AX)                             // XORL AX, AX
   608      self.Emit("SUBQ", jit.Imm(1), jit.Ptr(_ST, _ST_Sp))     // SUBQ $1, ST.Sp
   609      self.Emit("MOVQ", _AX, jit.Sib(_ST, _CX, 8, _ST_Vp))    // MOVQ AX, ST.Vp[CX]
   610      self.Sjmp("JMP" , "_next")                              // JMP  _next
   611  
   612      /* return from decoder */
   613      self.Link("_return")                            // _return:
   614      self.Emit("XORL", _EP, _EP)                     // XORL EP, EP
   615      self.Emit("MOVQ", _EP, jit.Ptr(_ST, _ST_Vp))    // MOVQ EP, ST.Vp[0]
   616      self.Link("_epilogue")                          // _epilogue:
   617      self.Emit("SUBQ", jit.Imm(_FsmOffset), _ST)     // SUBQ _FsmOffset, _ST
   618      self.Emit("MOVQ", jit.Ptr(_SP, _VD_offs), _BP)  // MOVQ _VD_offs(SP), BP
   619      self.Emit("ADDQ", jit.Imm(_VD_size), _SP)       // ADDQ $_VD_size, SP
   620      self.Emit("RET")                                // RET
   621  
   622      /* array expand */
   623      self.Link("_array_more")                    // _array_more:
   624      self.Emit("MOVQ" , _T_eface, _AX)           // MOVQ    _T_eface, AX
   625      self.Emit("MOVQ" , jit.Ptr(_SI, 0), _BX)    // MOVQ   (SI), BX
   626      self.Emit("MOVQ" , jit.Ptr(_SI, 8), _CX)    // MOVQ   8(SI), CX
   627      self.Emit("MOVQ" , jit.Ptr(_SI, 16), _DI)   // MOVQ    16(SI), DI
   628      self.Emit("MOVQ" , _DI, _SI)                // MOVQ    DI, 24(SP)
   629      self.Emit("SHLQ" , jit.Imm(1), _SI)         // SHLQ    $1, SI
   630      self.call_go(_F_growslice)                  // CALL_GO runtime.growslice
   631      self.Emit("MOVQ" , _AX, _DI)                // MOVQ   AX, DI
   632      self.Emit("MOVQ" , _BX, _DX)                // MOVQ   BX, DX
   633      self.Emit("MOVQ" , _CX, _AX)                // MOVQ   CX, AX
   634               
   635      /* update the slice */
   636      self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
   637      self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)    // MOVQ ST.Vp[CX], SI
   638      self.Emit("MOVQ", jit.Ptr(_SI, 8), _SI)                 // MOVQ 8(SI), SI
   639      self.Emit("MOVQ", _DX, jit.Ptr(_SI, 8))                 // MOVQ DX, 8(SI)
   640      self.Emit("MOVQ", _AX, jit.Ptr(_SI, 16))                // MOVQ AX, 16(AX)
   641      self.WriteRecNotAX(8 , _DI, jit.Ptr(_SI, 0), false)                 // MOVQ R10, (SI)
   642      self.Sjmp("JMP" , "_array_append")                      // JMP  _array_append
   643  
   644      /* copy string */
   645      self.Link("copy_string")  // pointer: R8, length: AX, return addr: DI
   646      self.Emit("MOVQ", _R8, _VAR_cs_p)
   647      self.Emit("MOVQ", _AX, _VAR_cs_n)
   648      self.Emit("MOVQ", _DI, _VAR_cs_LR)
   649      self.Emit("MOVQ", _AX, _BX)
   650      self.Emit("MOVQ", _AX, _CX)
   651      self.Emit("MOVQ", _T_byte, _AX)
   652      self.call_go(_F_makeslice)                              
   653      self.Emit("MOVQ", _AX, _VAR_cs_d)                    
   654      self.Emit("MOVQ", _VAR_cs_p, _BX)
   655      self.Emit("MOVQ", _VAR_cs_n, _CX)
   656      self.call_go(_F_memmove)
   657      self.Emit("MOVQ", _VAR_cs_d, _R8)
   658      self.Emit("MOVQ", _VAR_cs_n, _AX)
   659      self.Emit("MOVQ", _VAR_cs_LR, _DI)
   660      self.Rjmp("JMP", _DI)
   661  
   662      /* error handlers */
   663      self.Link("_stack_overflow")
   664      self.Emit("MOVL" , _E_recurse, _EP)         // MOVQ  _E_recurse, EP
   665      self.Sjmp("JMP"  , "_error")                // JMP   _error
   666      self.Link("_vtype_error")                   // _vtype_error:
   667      self.Emit("MOVQ" , _DI, _IC)                // MOVQ  DI, IC
   668      self.Emit("MOVL" , _E_invalid, _EP)         // MOVL  _E_invalid, EP
   669      self.Sjmp("JMP"  , "_error")                // JMP   _error
   670      self.Link("_invalid_char")                  // _invalid_char:
   671      self.Emit("SUBQ" , jit.Imm(1), _IC)         // SUBQ  $1, IC
   672      self.Emit("MOVL" , _E_invalid, _EP)         // MOVL  _E_invalid, EP
   673      self.Sjmp("JMP"  , "_error")                // JMP   _error
   674      self.Link("_unquote_error")                 // _unquote_error:
   675      self.Emit("MOVQ" , _VAR_ss_Iv, _IC)         // MOVQ  ss.Iv, IC
   676      self.Emit("SUBQ" , jit.Imm(1), _IC)         // SUBQ  $1, IC
   677      self.Link("_parsing_error")                 // _parsing_error:
   678      self.Emit("NEGQ" , _AX)                     // NEGQ  AX
   679      self.Emit("MOVQ" , _AX, _EP)                // MOVQ  AX, EP
   680      self.Link("_error")                         // _error:
   681      self.Emit("PXOR" , _X0, _X0)                // PXOR  X0, X0
   682      self.Emit("MOVOU", _X0, jit.Ptr(_VP, 0))    // MOVOU X0, (VP)
   683      self.Sjmp("JMP"  , "_epilogue")             // JMP   _epilogue
   684  
   685      /* invalid value type, never returns */
   686      self.Link("_invalid_vtype")
   687      self.call_go(_F_invalid_vtype)                 // CALL invalid_type
   688      self.Emit("UD2")                            // UD2
   689  
   690      /* switch jump table */
   691      self.Link("_switch_table")              // _switch_table:
   692      self.Sref("_decode_V_EOF", 0)           // SREF &_decode_V_EOF, $0
   693      self.Sref("_decode_V_NULL", -4)         // SREF &_decode_V_NULL, $-4
   694      self.Sref("_decode_V_TRUE", -8)         // SREF &_decode_V_TRUE, $-8
   695      self.Sref("_decode_V_FALSE", -12)       // SREF &_decode_V_FALSE, $-12
   696      self.Sref("_decode_V_ARRAY", -16)       // SREF &_decode_V_ARRAY, $-16
   697      self.Sref("_decode_V_OBJECT", -20)      // SREF &_decode_V_OBJECT, $-20
   698      self.Sref("_decode_V_STRING", -24)      // SREF &_decode_V_STRING, $-24
   699      self.Sref("_decode_V_DOUBLE", -28)      // SREF &_decode_V_DOUBLE, $-28
   700      self.Sref("_decode_V_INTEGER", -32)     // SREF &_decode_V_INTEGER, $-32
   701      self.Sref("_decode_V_KEY_SEP", -36)     // SREF &_decode_V_KEY_SEP, $-36
   702      self.Sref("_decode_V_ELEM_SEP", -40)    // SREF &_decode_V_ELEM_SEP, $-40
   703      self.Sref("_decode_V_ARRAY_END", -44)   // SREF &_decode_V_ARRAY_END, $-44
   704      self.Sref("_decode_V_OBJECT_END", -48)  // SREF &_decode_V_OBJECT_END, $-48
   705  
   706      /* fast character lookup table */
   707      self.Link("_decode_tab")        // _decode_tab:
   708      self.Sref("_decode_V_EOF", 0)   // SREF &_decode_V_EOF, $0
   709  
   710      /* generate rest of the tabs */
   711      for i := 1; i < 256; i++ {
   712          if to, ok := _R_tab[i]; ok {
   713              self.Sref(to, -int64(i) * 4)
   714          } else {
   715              self.Byte(0x00, 0x00, 0x00, 0x00)
   716          }
   717      }
   718  }
   719  
   720  /** Generic Decoder **/
   721  
   722  var (
   723      _subr_decode_value = new(_ValueDecoder).build()
   724  )
   725  
   726  //go:nosplit
   727  func invalid_vtype(vt types.ValueType) {
   728      throw(fmt.Sprintf("invalid value type: %d", vt))
   729  }
   730  

View as plain text