Source file src/github.com/bytedance/sonic/internal/decoder/assembler_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      `math`
    25      `reflect`
    26      `unsafe`
    27  
    28      `github.com/bytedance/sonic/internal/caching`
    29      `github.com/bytedance/sonic/internal/jit`
    30      `github.com/bytedance/sonic/internal/native`
    31      `github.com/bytedance/sonic/internal/native/types`
    32      `github.com/bytedance/sonic/internal/rt`
    33      `github.com/twitchyliquid64/golang-asm/obj`
    34  )
    35  
    36  /** Register Allocations
    37   *
    38   *  State Registers:
    39   *
    40   *      %r13 : stack base
    41   *      %r10 : input pointer
    42   *      %r12 : input length
    43   *      %r11 : input cursor
    44   *      %r15 : value pointer
    45   *
    46   *  Error Registers:
    47   *
    48   *      %rax : error type register
    49   *      %rbx : error pointer register
    50   */
    51  
    52  /** Function Prototype & Stack Map
    53   *
    54   *  func (s string, ic int, vp unsafe.Pointer, sb *_Stack, fv uint64, sv string) (rc int, err error)
    55   *
    56   *  s.buf  :   (FP)
    57   *  s.len  :  8(FP)
    58   *  ic     : 16(FP)
    59   *  vp     : 24(FP)
    60   *  sb     : 32(FP)
    61   *  fv     : 40(FP)
    62   *  sv     : 56(FP)
    63   *  err.vt : 72(FP)
    64   *  err.vp : 80(FP)
    65   */
    66  
    67  const (
    68      _FP_args   = 72     // 72 bytes to pass and spill register arguements
    69      _FP_fargs  = 80     // 80 bytes for passing arguments to other Go functions
    70      _FP_saves  = 48     // 48 bytes for saving the registers before CALL instructions
    71      _FP_locals = 144    // 144 bytes for local variables
    72  )
    73  
    74  const (
    75      _FP_offs = _FP_fargs + _FP_saves + _FP_locals
    76      _FP_size = _FP_offs + 8     // 8 bytes for the parent frame pointer
    77      _FP_base = _FP_size + 8     // 8 bytes for the return address
    78  )
    79  
    80  const (
    81      _IM_null = 0x6c6c756e   // 'null'
    82      _IM_true = 0x65757274   // 'true'
    83      _IM_alse = 0x65736c61   // 'alse' ('false' without the 'f')
    84  )
    85  
    86  const (
    87      _BM_space = (1 << ' ') | (1 << '\t') | (1 << '\r') | (1 << '\n')
    88  )
    89  
    90  const (
    91      _MODE_JSON = 1 << 3 // base64 mode
    92  )
    93  
    94  const (
    95      _LB_error           = "_error"
    96      _LB_im_error        = "_im_error"
    97      _LB_eof_error       = "_eof_error"
    98      _LB_type_error      = "_type_error"
    99      _LB_field_error     = "_field_error"
   100      _LB_range_error     = "_range_error"
   101      _LB_stack_error     = "_stack_error"
   102      _LB_base64_error    = "_base64_error"
   103      _LB_unquote_error   = "_unquote_error"
   104      _LB_parsing_error   = "_parsing_error"
   105      _LB_parsing_error_v = "_parsing_error_v"
   106      _LB_mismatch_error   = "_mismatch_error"
   107  )
   108  
   109  const (
   110      _LB_char_0_error  = "_char_0_error"
   111      _LB_char_1_error  = "_char_1_error"
   112      _LB_char_2_error  = "_char_2_error"
   113      _LB_char_3_error  = "_char_3_error"
   114      _LB_char_4_error  = "_char_4_error"
   115      _LB_char_m2_error = "_char_m2_error"
   116      _LB_char_m3_error = "_char_m3_error"
   117  )
   118  
   119  const (
   120      _LB_skip_one = "_skip_one"
   121      _LB_skip_key_value = "_skip_key_value"
   122  )
   123  
   124  var (
   125      _AX = jit.Reg("AX")
   126      _BX = jit.Reg("BX")
   127      _CX = jit.Reg("CX")
   128      _DX = jit.Reg("DX")
   129      _DI = jit.Reg("DI")
   130      _SI = jit.Reg("SI")
   131      _BP = jit.Reg("BP")
   132      _SP = jit.Reg("SP")
   133      _R8 = jit.Reg("R8")
   134      _R9 = jit.Reg("R9")
   135      _X0 = jit.Reg("X0")
   136      _X1 = jit.Reg("X1")
   137      _X15 = jit.Reg("X15")
   138  )
   139  
   140  var (
   141      _IP = jit.Reg("R10")  // saved on BP when callc
   142      _IC = jit.Reg("R11")  // saved on BX when call_c
   143      _IL = jit.Reg("R12")
   144      _ST = jit.Reg("R13")
   145      _VP = jit.Reg("R15")
   146  )
   147  
   148  var (
   149      _DF = jit.Reg("AX")    // reuse AX in generic decoder for flags
   150      _ET = jit.Reg("AX")
   151      _EP = jit.Reg("BX")
   152  )
   153  
   154  
   155  
   156  var (
   157      _ARG_s  = _ARG_sp
   158      _ARG_sp = jit.Ptr(_SP, _FP_base + 0)
   159      _ARG_sl = jit.Ptr(_SP, _FP_base + 8)
   160      _ARG_ic = jit.Ptr(_SP, _FP_base + 16)
   161      _ARG_vp = jit.Ptr(_SP, _FP_base + 24)
   162      _ARG_sb = jit.Ptr(_SP, _FP_base + 32)
   163      _ARG_fv = jit.Ptr(_SP, _FP_base + 40)
   164  )
   165  
   166  var (
   167      _ARG_sv   = _ARG_sv_p
   168      _ARG_sv_p = jit.Ptr(_SP, _FP_base + 48)
   169      _ARG_sv_n = jit.Ptr(_SP, _FP_base + 56)
   170      _ARG_vk   = jit.Ptr(_SP, _FP_base + 64)
   171  )
   172  
   173  var (
   174      _VAR_st = _VAR_st_Vt
   175      _VAR_sr = jit.Ptr(_SP, _FP_fargs + _FP_saves)
   176  )
   177  
   178  var (
   179      _VAR_st_Vt = jit.Ptr(_SP, _FP_fargs + _FP_saves + 0)
   180      _VAR_st_Dv = jit.Ptr(_SP, _FP_fargs + _FP_saves + 8)
   181      _VAR_st_Iv = jit.Ptr(_SP, _FP_fargs + _FP_saves + 16)
   182      _VAR_st_Ep = jit.Ptr(_SP, _FP_fargs + _FP_saves + 24)
   183      _VAR_st_Db = jit.Ptr(_SP, _FP_fargs + _FP_saves + 32)
   184      _VAR_st_Dc = jit.Ptr(_SP, _FP_fargs + _FP_saves + 40)
   185  )
   186  
   187  var (
   188      _VAR_ss_AX = jit.Ptr(_SP, _FP_fargs + _FP_saves + 48)
   189      _VAR_ss_CX = jit.Ptr(_SP, _FP_fargs + _FP_saves + 56)
   190      _VAR_ss_SI = jit.Ptr(_SP, _FP_fargs + _FP_saves + 64)
   191      _VAR_ss_R8 = jit.Ptr(_SP, _FP_fargs + _FP_saves + 72)
   192      _VAR_ss_R9 = jit.Ptr(_SP, _FP_fargs + _FP_saves + 80)
   193  )
   194  
   195  var (
   196      _VAR_bs_p = jit.Ptr(_SP, _FP_fargs + _FP_saves + 88)
   197      _VAR_bs_n = jit.Ptr(_SP, _FP_fargs + _FP_saves + 96)
   198      _VAR_bs_LR = jit.Ptr(_SP, _FP_fargs + _FP_saves + 104)
   199  )
   200  
   201  var _VAR_fl = jit.Ptr(_SP, _FP_fargs + _FP_saves + 112)
   202  
   203  var (
   204      _VAR_et = jit.Ptr(_SP, _FP_fargs + _FP_saves + 120) // save dismatched type
   205      _VAR_pc = jit.Ptr(_SP, _FP_fargs + _FP_saves + 128) // save skip return pc
   206      _VAR_ic = jit.Ptr(_SP, _FP_fargs + _FP_saves + 136) // save dismatched position
   207  )
   208  
   209  type _Assembler struct {
   210      jit.BaseAssembler
   211      p _Program
   212      name string
   213  }
   214  
   215  func newAssembler(p _Program) *_Assembler {
   216      return new(_Assembler).Init(p)
   217  }
   218  
   219  /** Assembler Interface **/
   220  
   221  func (self *_Assembler) Load() _Decoder {
   222      return ptodec(self.BaseAssembler.Load("decode_"+self.name, _FP_size, _FP_args, argPtrs, localPtrs))
   223  }
   224  
   225  func (self *_Assembler) Init(p _Program) *_Assembler {
   226      self.p = p
   227      self.BaseAssembler.Init(self.compile)
   228      return self
   229  }
   230  
   231  func (self *_Assembler) compile() {
   232      self.prologue()
   233      self.instrs()
   234      self.epilogue()
   235      self.copy_string()
   236      self.escape_string()
   237      self.escape_string_twice()
   238      self.skip_one()
   239      self.skip_key_value()
   240      self.type_error()
   241      self.mismatch_error()
   242      self.field_error()
   243      self.range_error()
   244      self.stack_error()
   245      self.base64_error()
   246      self.parsing_error()
   247  }
   248  
   249  /** Assembler Stages **/
   250  
   251  var _OpFuncTab = [256]func(*_Assembler, *_Instr) {
   252      _OP_any              : (*_Assembler)._asm_OP_any,
   253      _OP_dyn              : (*_Assembler)._asm_OP_dyn,
   254      _OP_str              : (*_Assembler)._asm_OP_str,
   255      _OP_bin              : (*_Assembler)._asm_OP_bin,
   256      _OP_bool             : (*_Assembler)._asm_OP_bool,
   257      _OP_num              : (*_Assembler)._asm_OP_num,
   258      _OP_i8               : (*_Assembler)._asm_OP_i8,
   259      _OP_i16              : (*_Assembler)._asm_OP_i16,
   260      _OP_i32              : (*_Assembler)._asm_OP_i32,
   261      _OP_i64              : (*_Assembler)._asm_OP_i64,
   262      _OP_u8               : (*_Assembler)._asm_OP_u8,
   263      _OP_u16              : (*_Assembler)._asm_OP_u16,
   264      _OP_u32              : (*_Assembler)._asm_OP_u32,
   265      _OP_u64              : (*_Assembler)._asm_OP_u64,
   266      _OP_f32              : (*_Assembler)._asm_OP_f32,
   267      _OP_f64              : (*_Assembler)._asm_OP_f64,
   268      _OP_unquote          : (*_Assembler)._asm_OP_unquote,
   269      _OP_nil_1            : (*_Assembler)._asm_OP_nil_1,
   270      _OP_nil_2            : (*_Assembler)._asm_OP_nil_2,
   271      _OP_nil_3            : (*_Assembler)._asm_OP_nil_3,
   272      _OP_deref            : (*_Assembler)._asm_OP_deref,
   273      _OP_index            : (*_Assembler)._asm_OP_index,
   274      _OP_is_null          : (*_Assembler)._asm_OP_is_null,
   275      _OP_is_null_quote    : (*_Assembler)._asm_OP_is_null_quote,
   276      _OP_map_init         : (*_Assembler)._asm_OP_map_init,
   277      _OP_map_key_i8       : (*_Assembler)._asm_OP_map_key_i8,
   278      _OP_map_key_i16      : (*_Assembler)._asm_OP_map_key_i16,
   279      _OP_map_key_i32      : (*_Assembler)._asm_OP_map_key_i32,
   280      _OP_map_key_i64      : (*_Assembler)._asm_OP_map_key_i64,
   281      _OP_map_key_u8       : (*_Assembler)._asm_OP_map_key_u8,
   282      _OP_map_key_u16      : (*_Assembler)._asm_OP_map_key_u16,
   283      _OP_map_key_u32      : (*_Assembler)._asm_OP_map_key_u32,
   284      _OP_map_key_u64      : (*_Assembler)._asm_OP_map_key_u64,
   285      _OP_map_key_f32      : (*_Assembler)._asm_OP_map_key_f32,
   286      _OP_map_key_f64      : (*_Assembler)._asm_OP_map_key_f64,
   287      _OP_map_key_str      : (*_Assembler)._asm_OP_map_key_str,
   288      _OP_map_key_utext    : (*_Assembler)._asm_OP_map_key_utext,
   289      _OP_map_key_utext_p  : (*_Assembler)._asm_OP_map_key_utext_p,
   290      _OP_array_skip       : (*_Assembler)._asm_OP_array_skip,
   291      _OP_array_clear      : (*_Assembler)._asm_OP_array_clear,
   292      _OP_array_clear_p    : (*_Assembler)._asm_OP_array_clear_p,
   293      _OP_slice_init       : (*_Assembler)._asm_OP_slice_init,
   294      _OP_slice_append     : (*_Assembler)._asm_OP_slice_append,
   295      _OP_object_skip      : (*_Assembler)._asm_OP_object_skip,
   296      _OP_object_next      : (*_Assembler)._asm_OP_object_next,
   297      _OP_struct_field     : (*_Assembler)._asm_OP_struct_field,
   298      _OP_unmarshal        : (*_Assembler)._asm_OP_unmarshal,
   299      _OP_unmarshal_p      : (*_Assembler)._asm_OP_unmarshal_p,
   300      _OP_unmarshal_text   : (*_Assembler)._asm_OP_unmarshal_text,
   301      _OP_unmarshal_text_p : (*_Assembler)._asm_OP_unmarshal_text_p,
   302      _OP_lspace           : (*_Assembler)._asm_OP_lspace,
   303      _OP_match_char       : (*_Assembler)._asm_OP_match_char,
   304      _OP_check_char       : (*_Assembler)._asm_OP_check_char,
   305      _OP_load             : (*_Assembler)._asm_OP_load,
   306      _OP_save             : (*_Assembler)._asm_OP_save,
   307      _OP_drop             : (*_Assembler)._asm_OP_drop,
   308      _OP_drop_2           : (*_Assembler)._asm_OP_drop_2,
   309      _OP_recurse          : (*_Assembler)._asm_OP_recurse,
   310      _OP_goto             : (*_Assembler)._asm_OP_goto,
   311      _OP_switch           : (*_Assembler)._asm_OP_switch,
   312      _OP_check_char_0     : (*_Assembler)._asm_OP_check_char_0,
   313      _OP_dismatch_err     : (*_Assembler)._asm_OP_dismatch_err,
   314      _OP_go_skip          : (*_Assembler)._asm_OP_go_skip,
   315      _OP_add              : (*_Assembler)._asm_OP_add,
   316      _OP_check_empty      : (*_Assembler)._asm_OP_check_empty,
   317      _OP_debug            : (*_Assembler)._asm_OP_debug,
   318  }
   319  
   320  func (self *_Assembler) _asm_OP_debug(_ *_Instr) {
   321      self.Byte(0xcc)
   322  }
   323  
   324  func (self *_Assembler) instr(v *_Instr) {
   325      if fn := _OpFuncTab[v.op()]; fn != nil {
   326          fn(self, v)
   327      } else {
   328          panic(fmt.Sprintf("invalid opcode: %d", v.op()))
   329      }
   330  }
   331  
   332  func (self *_Assembler) instrs() {
   333      for i, v := range self.p {
   334          self.Mark(i)
   335          self.instr(&v)
   336          self.debug_instr(i, &v)
   337      }
   338  }
   339  
   340  func (self *_Assembler) epilogue() {
   341      self.Mark(len(self.p))
   342      self.Emit("XORL", _EP, _EP)                     // XORL EP, EP
   343      self.Emit("MOVQ", _VAR_et, _ET)                 // MOVQ VAR_et, ET
   344      self.Emit("TESTQ", _ET, _ET)                    // TESTQ ET, ET
   345      self.Sjmp("JNZ", _LB_mismatch_error)            // JNZ _LB_mismatch_error
   346      self.Link(_LB_error)                            // _error:
   347      self.Emit("MOVQ", _EP, _CX)                     // MOVQ BX, CX
   348      self.Emit("MOVQ", _ET, _BX)                     // MOVQ AX, BX
   349      self.Emit("MOVQ", _IC, _AX)                     // MOVQ IC, AX
   350      self.Emit("MOVQ", jit.Imm(0), _ARG_sp)          // MOVQ $0, sv.p<>+48(FP)
   351      self.Emit("MOVQ", jit.Imm(0), _ARG_vp)          // MOVQ $0, sv.p<>+48(FP)
   352      self.Emit("MOVQ", jit.Imm(0), _ARG_sv_p)        // MOVQ $0, sv.p<>+48(FP)
   353      self.Emit("MOVQ", jit.Imm(0), _ARG_vk)          // MOVQ $0, vk<>+64(FP)
   354      self.Emit("MOVQ", jit.Ptr(_SP, _FP_offs), _BP)  // MOVQ _FP_offs(SP), BP
   355      self.Emit("ADDQ", jit.Imm(_FP_size), _SP)       // ADDQ $_FP_size, SP
   356      self.Emit("RET")                                // RET
   357  }
   358  
   359  func (self *_Assembler) prologue() {
   360      self.Emit("SUBQ", jit.Imm(_FP_size), _SP)       // SUBQ $_FP_size, SP
   361      self.Emit("MOVQ", _BP, jit.Ptr(_SP, _FP_offs))  // MOVQ BP, _FP_offs(SP)
   362      self.Emit("LEAQ", jit.Ptr(_SP, _FP_offs), _BP)  // LEAQ _FP_offs(SP), BP
   363      self.Emit("MOVQ", _AX, _ARG_sp)                 // MOVQ AX, s.p<>+0(FP)
   364      self.Emit("MOVQ", _AX, _IP)                     // MOVQ AX, IP
   365      self.Emit("MOVQ", _BX, _ARG_sl)                 // MOVQ BX, s.l<>+8(FP)
   366      self.Emit("MOVQ", _BX, _IL)                     // MOVQ BX, IL
   367      self.Emit("MOVQ", _CX, _ARG_ic)                 // MOVQ CX, ic<>+16(FP)
   368      self.Emit("MOVQ", _CX, _IC)                     // MOVQ CX, IC
   369      self.Emit("MOVQ", _DI, _ARG_vp)                 // MOVQ DI, vp<>+24(FP)
   370      self.Emit("MOVQ", _DI, _VP)                     // MOVQ DI, VP
   371      self.Emit("MOVQ", _SI, _ARG_sb)                 // MOVQ SI, sb<>+32(FP)
   372      self.Emit("MOVQ", _SI, _ST)                     // MOVQ SI, ST
   373      self.Emit("MOVQ", _R8, _ARG_fv)                 // MOVQ R8, fv<>+40(FP)
   374      self.Emit("MOVQ", jit.Imm(0), _ARG_sv_p)        // MOVQ $0, sv.p<>+48(FP)
   375      self.Emit("MOVQ", jit.Imm(0), _ARG_sv_n)        // MOVQ $0, sv.n<>+56(FP)
   376      self.Emit("MOVQ", jit.Imm(0), _ARG_vk)          // MOVQ $0, vk<>+64(FP)
   377      self.Emit("MOVQ", jit.Imm(0), _VAR_et)          // MOVQ $0, et<>+120(FP)
   378      // initialize digital buffer first
   379      self.Emit("MOVQ", jit.Imm(_MaxDigitNums), _VAR_st_Dc)    // MOVQ $_MaxDigitNums, ss.Dcap
   380      self.Emit("LEAQ", jit.Ptr(_ST, _DbufOffset), _AX)        // LEAQ _DbufOffset(ST), AX
   381      self.Emit("MOVQ", _AX, _VAR_st_Db)                       // MOVQ AX, ss.Dbuf
   382  }
   383  
   384  /** Function Calling Helpers **/
   385  
   386  var (
   387      _REG_go = []obj.Addr { _ST, _VP, _IP, _IL, _IC }
   388      _REG_rt = []obj.Addr { _ST, _VP, _IP, _IL, _IC, _IL }
   389  )
   390  
   391  func (self *_Assembler) save(r ...obj.Addr) {
   392      for i, v := range r {
   393          if i > _FP_saves / 8 - 1 {
   394              panic("too many registers to save")
   395          } else {
   396              self.Emit("MOVQ", v, jit.Ptr(_SP, _FP_fargs + int64(i) * 8))
   397          }
   398      }
   399  }
   400  
   401  func (self *_Assembler) load(r ...obj.Addr) {
   402      for i, v := range r {
   403          if i > _FP_saves / 8 - 1 {
   404              panic("too many registers to load")
   405          } else {
   406              self.Emit("MOVQ", jit.Ptr(_SP, _FP_fargs + int64(i) * 8), v)
   407          }
   408      }
   409  }
   410  
   411  func (self *_Assembler) call(fn obj.Addr) {
   412      self.Emit("MOVQ", fn, _R9)  // MOVQ ${fn}, R11
   413      self.Rjmp("CALL", _R9)      // CALL R11
   414  }
   415  
   416  func (self *_Assembler) call_go(fn obj.Addr) {
   417      self.save(_REG_go...)   // SAVE $REG_go
   418      self.call(fn)
   419      self.load(_REG_go...)   // LOAD $REG_go
   420  }
   421  
   422  func (self *_Assembler) callc(fn obj.Addr) {
   423      self.save(_IP)
   424      self.call(fn)
   425      self.Emit("XORPS", _X15, _X15)
   426      self.load(_IP)
   427  }
   428  
   429  func (self *_Assembler) call_c(fn obj.Addr) {
   430      self.Emit("XCHGQ", _IC, _BX)
   431      self.callc(fn)
   432      self.Emit("XCHGQ", _IC, _BX)
   433  }
   434  
   435  func (self *_Assembler) call_sf(fn obj.Addr) {
   436      self.Emit("LEAQ", _ARG_s, _DI)                      // LEAQ s<>+0(FP), DI
   437      self.Emit("MOVQ", _IC, _ARG_ic)                     // MOVQ IC, ic<>+16(FP)
   438      self.Emit("LEAQ", _ARG_ic, _SI)                     // LEAQ ic<>+16(FP), SI
   439      self.Emit("LEAQ", jit.Ptr(_ST, _FsmOffset), _DX)    // LEAQ _FsmOffset(ST), DX
   440      self.Emit("MOVQ", _ARG_fv, _CX)
   441      self.callc(fn)
   442      self.Emit("MOVQ", _ARG_ic, _IC)                     // MOVQ ic<>+16(FP), IC
   443  }
   444  
   445  func (self *_Assembler) call_vf(fn obj.Addr) {
   446      self.Emit("LEAQ", _ARG_s, _DI)      // LEAQ s<>+0(FP), DI
   447      self.Emit("MOVQ", _IC, _ARG_ic)     // MOVQ IC, ic<>+16(FP)
   448      self.Emit("LEAQ", _ARG_ic, _SI)     // LEAQ ic<>+16(FP), SI
   449      self.Emit("LEAQ", _VAR_st, _DX)     // LEAQ st, DX
   450      self.callc(fn)
   451      self.Emit("MOVQ", _ARG_ic, _IC)     // MOVQ ic<>+16(FP), IC
   452  }
   453  
   454  /** Assembler Error Handlers **/
   455  
   456  var (
   457      _F_convT64        = jit.Func(convT64)
   458      _F_error_wrap     = jit.Func(error_wrap)
   459      _F_error_type     = jit.Func(error_type)
   460      _F_error_field    = jit.Func(error_field)
   461      _F_error_value    = jit.Func(error_value)
   462      _F_error_mismatch = jit.Func(error_mismatch)
   463  )
   464  
   465  var (
   466      _I_int8    , _T_int8    = rtype(reflect.TypeOf(int8(0)))
   467      _I_int16   , _T_int16   = rtype(reflect.TypeOf(int16(0)))
   468      _I_int32   , _T_int32   = rtype(reflect.TypeOf(int32(0)))
   469      _I_uint8   , _T_uint8   = rtype(reflect.TypeOf(uint8(0)))
   470      _I_uint16  , _T_uint16  = rtype(reflect.TypeOf(uint16(0)))
   471      _I_uint32  , _T_uint32  = rtype(reflect.TypeOf(uint32(0)))
   472      _I_float32 , _T_float32 = rtype(reflect.TypeOf(float32(0)))
   473  )
   474  
   475  var (
   476      _T_error                    = rt.UnpackType(errorType)
   477      _I_base64_CorruptInputError = jit.Itab(_T_error, base64CorruptInputError)
   478  )
   479  
   480  var (
   481      _V_stackOverflow              = jit.Imm(int64(uintptr(unsafe.Pointer(&stackOverflow))))
   482      _I_json_UnsupportedValueError = jit.Itab(_T_error, reflect.TypeOf(new(json.UnsupportedValueError)))
   483      _I_json_MismatchTypeError     = jit.Itab(_T_error, reflect.TypeOf(new(MismatchTypeError)))
   484  )
   485  
   486  func (self *_Assembler) type_error() {
   487      self.Link(_LB_type_error)                   // _type_error:
   488      self.call_go(_F_error_type)                 // CALL_GO error_type
   489      self.Sjmp("JMP" , _LB_error)                // JMP     _error
   490  }
   491  
   492  func (self *_Assembler) mismatch_error() {
   493      self.Link(_LB_mismatch_error)                     // _type_error:
   494      self.Emit("MOVQ", _VAR_et, _ET)                   // MOVQ _VAR_et, ET
   495      self.Emit("MOVQ", _VAR_ic, _EP)                   // MOVQ _VAR_ic, EP
   496      self.Emit("MOVQ", _I_json_MismatchTypeError, _CX) // MOVQ _I_json_MismatchType, CX
   497      self.Emit("CMPQ", _ET, _CX)                       // CMPQ ET, CX
   498      self.Sjmp("JE"  , _LB_error)                      // JE _LB_error
   499      self.Emit("MOVQ", _ARG_sp, _AX)
   500      self.Emit("MOVQ", _ARG_sl, _BX)
   501      self.Emit("MOVQ", _VAR_ic, _CX)
   502      self.Emit("MOVQ", _VAR_et, _DI)
   503      self.call_go(_F_error_mismatch)             // CALL_GO error_type
   504      self.Sjmp("JMP" , _LB_error)                // JMP     _error
   505  }
   506  
   507  func (self *_Assembler) field_error() {
   508      self.Link(_LB_field_error)                  // _field_error:
   509      self.Emit("MOVQ", _ARG_sv_p, _AX)           // MOVQ   sv.p, AX
   510      self.Emit("MOVQ", _ARG_sv_n, _BX)           // MOVQ   sv.n, BX
   511      self.call_go(_F_error_field)                // CALL_GO error_field
   512      self.Sjmp("JMP" , _LB_error)                // JMP     _error
   513  }
   514  
   515  func (self *_Assembler) range_error() {
   516      self.Link(_LB_range_error)                  // _range_error:
   517      self.Emit("MOVQ", _ET, _CX)                 // MOVQ    ET, CX
   518      self.slice_from(_VAR_st_Ep, 0)              // SLICE   st.Ep, $0
   519      self.Emit("MOVQ", _DI, _AX)                 // MOVQ    DI, AX
   520      self.Emit("MOVQ", _EP, _DI)                 // MOVQ    EP, DI
   521      self.Emit("MOVQ", _SI, _BX)                 // MOVQ    SI, BX
   522      self.call_go(_F_error_value)                // CALL_GO error_value
   523      self.Sjmp("JMP" , _LB_error)                // JMP     _error
   524  }
   525  
   526  func (self *_Assembler) stack_error() {
   527      self.Link(_LB_stack_error)                              // _stack_error:
   528      self.Emit("MOVQ", _V_stackOverflow, _EP)                // MOVQ ${_V_stackOverflow}, EP
   529      self.Emit("MOVQ", _I_json_UnsupportedValueError, _ET)   // MOVQ ${_I_json_UnsupportedValueError}, ET
   530      self.Sjmp("JMP" , _LB_error)                            // JMP  _error
   531  }
   532  
   533  func (self *_Assembler) base64_error() {
   534      self.Link(_LB_base64_error)
   535      self.Emit("NEGQ", _AX)                                  // NEGQ    AX
   536      self.Emit("SUBQ", jit.Imm(1), _AX)                      // SUBQ    $1, AX
   537      self.call_go(_F_convT64)                                // CALL_GO convT64
   538      self.Emit("MOVQ", _AX, _EP)                             // MOVQ    AX, EP
   539      self.Emit("MOVQ", _I_base64_CorruptInputError, _ET)     // MOVQ    ${itab(base64.CorruptInputError)}, ET
   540      self.Sjmp("JMP" , _LB_error)                            // JMP     _error
   541  }
   542  
   543  func (self *_Assembler) parsing_error() {
   544      self.Link(_LB_eof_error)                                            // _eof_error:
   545      self.Emit("MOVQ" , _IL, _IC)                                        // MOVQ    IL, IC
   546      self.Emit("MOVL" , jit.Imm(int64(types.ERR_EOF)), _EP)              // MOVL    ${types.ERR_EOF}, EP
   547      self.Sjmp("JMP"  , _LB_parsing_error)                               // JMP     _parsing_error
   548      self.Link(_LB_unquote_error)                                        // _unquote_error:
   549      self.Emit("SUBQ" , _VAR_sr, _SI)                                    // SUBQ    sr, SI
   550      self.Emit("SUBQ" , _SI, _IC)                                        // SUBQ    IL, IC
   551      self.Link(_LB_parsing_error_v)                                      // _parsing_error_v:
   552      self.Emit("MOVQ" , _AX, _EP)                                        // MOVQ    AX, EP
   553      self.Emit("NEGQ" , _EP)                                             // NEGQ    EP
   554      self.Sjmp("JMP"  , _LB_parsing_error)                               // JMP     _parsing_error
   555      self.Link(_LB_char_m3_error)                                        // _char_m3_error:
   556      self.Emit("SUBQ" , jit.Imm(1), _IC)                                 // SUBQ    $1, IC
   557      self.Link(_LB_char_m2_error)                                        // _char_m2_error:
   558      self.Emit("SUBQ" , jit.Imm(2), _IC)                                 // SUBQ    $2, IC
   559      self.Sjmp("JMP"  , _LB_char_0_error)                                // JMP     _char_0_error
   560      self.Link(_LB_im_error)                                             // _im_error:
   561      self.Emit("CMPB" , _CX, jit.Sib(_IP, _IC, 1, 0))                    // CMPB    CX, (IP)(IC)
   562      self.Sjmp("JNE"  , _LB_char_0_error)                                // JNE     _char_0_error
   563      self.Emit("SHRL" , jit.Imm(8), _CX)                                 // SHRL    $8, CX
   564      self.Emit("CMPB" , _CX, jit.Sib(_IP, _IC, 1, 1))                    // CMPB    CX, 1(IP)(IC)
   565      self.Sjmp("JNE"  , _LB_char_1_error)                                // JNE     _char_1_error
   566      self.Emit("SHRL" , jit.Imm(8), _CX)                                 // SHRL    $8, CX
   567      self.Emit("CMPB" , _CX, jit.Sib(_IP, _IC, 1, 2))                    // CMPB    CX, 2(IP)(IC)
   568      self.Sjmp("JNE"  , _LB_char_2_error)                                // JNE     _char_2_error
   569      self.Sjmp("JMP"  , _LB_char_3_error)                                // JNE     _char_3_error
   570      self.Link(_LB_char_4_error)                                         // _char_4_error:
   571      self.Emit("ADDQ" , jit.Imm(1), _IC)                                 // ADDQ    $1, IC
   572      self.Link(_LB_char_3_error)                                         // _char_3_error:
   573      self.Emit("ADDQ" , jit.Imm(1), _IC)                                 // ADDQ    $1, IC
   574      self.Link(_LB_char_2_error)                                         // _char_2_error:
   575      self.Emit("ADDQ" , jit.Imm(1), _IC)                                 // ADDQ    $1, IC
   576      self.Link(_LB_char_1_error)                                         // _char_1_error:
   577      self.Emit("ADDQ" , jit.Imm(1), _IC)                                 // ADDQ    $1, IC
   578      self.Link(_LB_char_0_error)                                         // _char_0_error:
   579      self.Emit("MOVL" , jit.Imm(int64(types.ERR_INVALID_CHAR)), _EP)     // MOVL    ${types.ERR_INVALID_CHAR}, EP
   580      self.Link(_LB_parsing_error)                                        // _parsing_error:
   581      self.Emit("MOVQ" , _EP, _DI)                                        // MOVQ    EP, DI
   582      self.Emit("MOVQ",  _ARG_sp, _AX)                                     // MOVQ  sp, AX
   583      self.Emit("MOVQ",  _ARG_sl, _BX)                                     // MOVQ  sl, BX
   584      self.Emit("MOVQ" , _IC, _CX)                                        // MOVQ    IC, CX
   585      self.call_go(_F_error_wrap)                                         // CALL_GO error_wrap
   586      self.Sjmp("JMP"  , _LB_error)                                       // JMP     _error
   587  }
   588  
   589  func (self *_Assembler) _asm_OP_dismatch_err(p *_Instr) {
   590      self.Emit("MOVQ", _IC, _VAR_ic)      
   591      self.Emit("MOVQ", jit.Type(p.vt()), _ET)     
   592      self.Emit("MOVQ", _ET, _VAR_et)
   593  }
   594  
   595  func (self *_Assembler) _asm_OP_go_skip(p *_Instr) {
   596      self.Byte(0x4c, 0x8d, 0x0d)         // LEAQ (PC), R9
   597      self.Xref(p.vi(), 4)
   598      // self.Byte(0xcc)
   599      self.Emit("MOVQ", _R9, _VAR_pc)
   600      self.Sjmp("JMP"  , _LB_skip_one)            // JMP     _skip_one
   601  }
   602  
   603  func (self *_Assembler) skip_one() {
   604      self.Link(_LB_skip_one)                     // _skip:
   605      self.Emit("MOVQ", _VAR_ic, _IC)             // MOVQ    _VAR_ic, IC
   606      self.call_sf(_F_skip_one)                   // CALL_SF skip_one
   607      self.Emit("TESTQ", _AX, _AX)                // TESTQ   AX, AX
   608      self.Sjmp("JS"   , _LB_parsing_error_v)     // JS      _parse_error_v
   609      self.Emit("MOVQ" , _VAR_pc, _R9)            // MOVQ    pc, R9
   610      self.Rjmp("JMP"  , _R9)                     // JMP     (R9)
   611  }
   612  
   613  func (self *_Assembler) skip_key_value() {
   614      self.Link(_LB_skip_key_value)               // _skip:
   615      // skip the key
   616      self.Emit("MOVQ", _VAR_ic, _IC)             // MOVQ    _VAR_ic, IC
   617      self.call_sf(_F_skip_one)                   // CALL_SF skip_one
   618      self.Emit("TESTQ", _AX, _AX)                // TESTQ   AX, AX
   619      self.Sjmp("JS"   , _LB_parsing_error_v)     // JS      _parse_error_v
   620      // match char ':'
   621      self.lspace("_global_1")
   622      self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm(':'))
   623      self.Sjmp("JNE"  , _LB_parsing_error_v)     // JNE     _parse_error_v
   624      self.Emit("ADDQ", jit.Imm(1), _IC)          // ADDQ    $1, IC
   625      self.lspace("_global_2")
   626      // skip the value
   627      self.call_sf(_F_skip_one)                   // CALL_SF skip_one
   628      self.Emit("TESTQ", _AX, _AX)                // TESTQ   AX, AX
   629      self.Sjmp("JS"   , _LB_parsing_error_v)     // JS      _parse_error_v
   630      // jump back to specified address
   631      self.Emit("MOVQ" , _VAR_pc, _R9)            // MOVQ    pc, R9
   632      self.Rjmp("JMP"  , _R9)                     // JMP     (R9)
   633  }
   634  
   635  
   636  /** Memory Management Routines **/
   637  
   638  var (
   639      _T_byte     = jit.Type(byteType)
   640      _F_mallocgc = jit.Func(mallocgc)
   641  )
   642  
   643  func (self *_Assembler) malloc_AX(nb obj.Addr, ret obj.Addr) {
   644      self.Emit("MOVQ", nb, _AX)                  // MOVQ    ${nb}, AX
   645      self.Emit("MOVQ", _T_byte, _BX)             // MOVQ    ${type(byte)}, BX
   646      self.Emit("XORL", _CX, _CX)                 // XORL    CX, CX
   647      self.call_go(_F_mallocgc)                   // CALL_GO mallocgc
   648      self.Emit("MOVQ", _AX, ret)                 // MOVQ    AX, ${ret}
   649  }
   650  
   651  func (self *_Assembler) valloc(vt reflect.Type, ret obj.Addr) {
   652      self.Emit("MOVQ", jit.Imm(int64(vt.Size())), _AX)   // MOVQ    ${vt.Size()}, AX
   653      self.Emit("MOVQ", jit.Type(vt), _BX)                // MOVQ    ${vt}, BX
   654      self.Emit("MOVB", jit.Imm(1), _CX)                  // MOVB    $1, CX
   655      self.call_go(_F_mallocgc)                           // CALL_GO mallocgc
   656      self.Emit("MOVQ", _AX, ret)                         // MOVQ    AX, ${ret}
   657  }
   658  
   659  func (self *_Assembler) valloc_AX(vt reflect.Type) {
   660      self.Emit("MOVQ", jit.Imm(int64(vt.Size())), _AX)   // MOVQ    ${vt.Size()}, AX
   661      self.Emit("MOVQ", jit.Type(vt), _BX)                // MOVQ    ${vt}, BX
   662      self.Emit("MOVB", jit.Imm(1), _CX)                  // MOVB    $1, CX
   663      self.call_go(_F_mallocgc)                           // CALL_GO mallocgc
   664  }
   665  
   666  func (self *_Assembler) vfollow(vt reflect.Type) {
   667      self.Emit("MOVQ" , jit.Ptr(_VP, 0), _AX)    // MOVQ   (VP), AX
   668      self.Emit("TESTQ", _AX, _AX)                // TESTQ  AX, AX
   669      self.Sjmp("JNZ"  , "_end_{n}")              // JNZ    _end_{n}
   670      self.valloc_AX(vt)                          // VALLOC ${vt}, AX
   671      self.WritePtrAX(1, jit.Ptr(_VP, 0), true)   // MOVQ   AX, (VP)
   672      self.Link("_end_{n}")                       // _end_{n}:
   673      self.Emit("MOVQ" , _AX, _VP)                // MOVQ   AX, VP
   674  }
   675  
   676  /** Value Parsing Routines **/
   677  
   678  var (
   679      _F_vstring   = jit.Imm(int64(native.S_vstring))
   680      _F_vnumber   = jit.Imm(int64(native.S_vnumber))
   681      _F_vsigned   = jit.Imm(int64(native.S_vsigned))
   682      _F_vunsigned = jit.Imm(int64(native.S_vunsigned))
   683  )
   684  
   685  func (self *_Assembler) check_err(vt reflect.Type, pin string, pin2 int) {
   686      self.Emit("MOVQ" , _VAR_st_Vt, _AX)         // MOVQ st.Vt, AX
   687      self.Emit("TESTQ", _AX, _AX)                // CMPQ AX, ${native.V_STRING}
   688      // try to skip the value
   689      if vt != nil {
   690          self.Sjmp("JNS" , "_check_err_{n}")        // JNE  _parsing_error_v
   691          self.Emit("MOVQ", jit.Type(vt), _ET)         
   692          self.Emit("MOVQ", _ET, _VAR_et)
   693          if pin2 != -1 {
   694              self.Emit("SUBQ", jit.Imm(1), _BX)
   695              self.Emit("MOVQ", _BX, _VAR_ic)
   696              self.Byte(0x4c  , 0x8d, 0x0d)         // LEAQ (PC), R9
   697              self.Xref(pin2, 4)
   698              self.Emit("MOVQ", _R9, _VAR_pc)
   699              self.Sjmp("JMP" , _LB_skip_key_value)
   700          } else {
   701              self.Emit("MOVQ", _BX, _VAR_ic)
   702              self.Byte(0x4c  , 0x8d, 0x0d)         // LEAQ (PC), R9
   703              self.Sref(pin, 4)
   704              self.Emit("MOVQ", _R9, _VAR_pc)
   705              self.Sjmp("JMP" , _LB_skip_one)
   706          }
   707          self.Link("_check_err_{n}")
   708      } else {
   709          self.Sjmp("JS"   , _LB_parsing_error_v)     // JNE  _parsing_error_v
   710      }
   711  }
   712  
   713  func (self *_Assembler) check_eof(d int64) {
   714      if d == 1 {
   715          self.Emit("CMPQ", _IC, _IL)         // CMPQ IC, IL
   716          self.Sjmp("JAE" , _LB_eof_error)    // JAE  _eof_error
   717      } else {
   718          self.Emit("LEAQ", jit.Ptr(_IC, d), _AX)     // LEAQ ${d}(IC), AX
   719          self.Emit("CMPQ", _AX, _IL)                 // CMPQ AX, IL
   720          self.Sjmp("JA"  , _LB_eof_error)            // JA   _eof_error
   721      }
   722  }
   723  
   724  
   725  func (self *_Assembler) parse_string() {
   726      self.Emit("MOVQ", _ARG_fv, _CX)
   727      self.call_vf(_F_vstring)
   728      self.check_err(nil, "", -1)
   729  }
   730  
   731  func (self *_Assembler) parse_number(vt reflect.Type, pin string, pin2 int) {
   732      self.Emit("MOVQ", _IC, _BX)       // save ic when call native func    
   733      self.call_vf(_F_vnumber)
   734      self.check_err(vt, pin, pin2)
   735  }
   736  
   737  func (self *_Assembler) parse_signed(vt reflect.Type, pin string, pin2 int) {
   738      self.Emit("MOVQ", _IC, _BX)       // save ic when call native func    
   739      self.call_vf(_F_vsigned)
   740      self.check_err(vt, pin, pin2)
   741  }
   742  
   743  func (self *_Assembler) parse_unsigned(vt reflect.Type, pin string, pin2 int) {
   744      self.Emit("MOVQ", _IC, _BX)       // save ic when call native func    
   745      self.call_vf(_F_vunsigned)
   746      self.check_err(vt, pin, pin2)
   747  }
   748  
   749  // Pointer: DI, Size: SI, Return: R9  
   750  func (self *_Assembler) copy_string() {
   751      self.Link("_copy_string")
   752      self.Emit("MOVQ", _DI, _VAR_bs_p)
   753      self.Emit("MOVQ", _SI, _VAR_bs_n)
   754      self.Emit("MOVQ", _R9, _VAR_bs_LR)
   755      self.malloc_AX(_SI, _ARG_sv_p)                              
   756      self.Emit("MOVQ", _VAR_bs_p, _BX)
   757      self.Emit("MOVQ", _VAR_bs_n, _CX)
   758      self.call_go(_F_memmove)
   759      self.Emit("MOVQ", _ARG_sv_p, _DI)
   760      self.Emit("MOVQ", _VAR_bs_n, _SI)
   761      self.Emit("MOVQ", _VAR_bs_LR, _R9)
   762      self.Rjmp("JMP", _R9)
   763  }
   764  
   765  // Pointer: DI, Size: SI, Return: R9
   766  func (self *_Assembler) escape_string() {
   767      self.Link("_escape_string")
   768      self.Emit("MOVQ" , _DI, _VAR_bs_p)
   769      self.Emit("MOVQ" , _SI, _VAR_bs_n)
   770      self.Emit("MOVQ" , _R9, _VAR_bs_LR)
   771      self.malloc_AX(_SI, _DX)                                    // MALLOC SI, DX
   772      self.Emit("MOVQ" , _DX, _ARG_sv_p)
   773      self.Emit("MOVQ" , _VAR_bs_p, _DI)
   774      self.Emit("MOVQ" , _VAR_bs_n, _SI)                                  
   775      self.Emit("LEAQ" , _VAR_sr, _CX)                            // LEAQ   sr, CX
   776      self.Emit("XORL" , _R8, _R8)                                // XORL   R8, R8
   777      self.Emit("BTQ"  , jit.Imm(_F_disable_urc), _ARG_fv)        // BTQ    ${_F_disable_urc}, fv
   778      self.Emit("SETCC", _R8)                                     // SETCC  R8
   779      self.Emit("SHLQ" , jit.Imm(types.B_UNICODE_REPLACE), _R8)   // SHLQ   ${types.B_UNICODE_REPLACE}, R8
   780      self.call_c(_F_unquote)                                       // CALL   unquote
   781      self.Emit("MOVQ" , _VAR_bs_n, _SI)                                  // MOVQ   ${n}, SI
   782      self.Emit("ADDQ" , jit.Imm(1), _SI)                         // ADDQ   $1, SI
   783      self.Emit("TESTQ", _AX, _AX)                                // TESTQ  AX, AX
   784      self.Sjmp("JS"   , _LB_unquote_error)                       // JS     _unquote_error
   785      self.Emit("MOVQ" , _AX, _SI)
   786      self.Emit("MOVQ" , _ARG_sv_p, _DI)
   787      self.Emit("MOVQ" , _VAR_bs_LR, _R9)
   788      self.Rjmp("JMP", _R9)
   789  }
   790  
   791  func (self *_Assembler) escape_string_twice() {
   792      self.Link("_escape_string_twice")
   793      self.Emit("MOVQ" , _DI, _VAR_bs_p)
   794      self.Emit("MOVQ" , _SI, _VAR_bs_n)
   795      self.Emit("MOVQ" , _R9, _VAR_bs_LR)
   796      self.malloc_AX(_SI, _DX)                                        // MALLOC SI, DX
   797      self.Emit("MOVQ" , _DX, _ARG_sv_p)
   798      self.Emit("MOVQ" , _VAR_bs_p, _DI)
   799      self.Emit("MOVQ" , _VAR_bs_n, _SI)        
   800      self.Emit("LEAQ" , _VAR_sr, _CX)                                // LEAQ   sr, CX
   801      self.Emit("MOVL" , jit.Imm(types.F_DOUBLE_UNQUOTE), _R8)        // MOVL   ${types.F_DOUBLE_UNQUOTE}, R8
   802      self.Emit("BTQ"  , jit.Imm(_F_disable_urc), _ARG_fv)            // BTQ    ${_F_disable_urc}, AX
   803      self.Emit("XORL" , _AX, _AX)                                    // XORL   AX, AX
   804      self.Emit("SETCC", _AX)                                         // SETCC  AX
   805      self.Emit("SHLQ" , jit.Imm(types.B_UNICODE_REPLACE), _AX)       // SHLQ   ${types.B_UNICODE_REPLACE}, AX
   806      self.Emit("ORQ"  , _AX, _R8)                                    // ORQ    AX, R8
   807      self.call_c(_F_unquote)                                         // CALL   unquote
   808      self.Emit("MOVQ" , _VAR_bs_n, _SI)                              // MOVQ   ${n}, SI
   809      self.Emit("ADDQ" , jit.Imm(3), _SI)                             // ADDQ   $3, SI
   810      self.Emit("TESTQ", _AX, _AX)                                    // TESTQ  AX, AX
   811      self.Sjmp("JS"   , _LB_unquote_error)                           // JS     _unquote_error
   812      self.Emit("MOVQ" , _AX, _SI)
   813      self.Emit("MOVQ" , _ARG_sv_p, _DI)
   814      self.Emit("MOVQ" , _VAR_bs_LR, _R9)
   815      self.Rjmp("JMP", _R9)
   816  }
   817  
   818  /** Range Checking Routines **/
   819  
   820  var (
   821      _V_max_f32 = jit.Imm(int64(uintptr(unsafe.Pointer(_Vp_max_f32))))
   822      _V_min_f32 = jit.Imm(int64(uintptr(unsafe.Pointer(_Vp_min_f32))))
   823  )
   824  
   825  var (
   826      _Vp_max_f32 = new(float32)
   827      _Vp_min_f32 = new(float32)
   828  )
   829  
   830  func init() {
   831      *_Vp_max_f32 = math.MaxFloat32
   832      *_Vp_min_f32 = -math.MaxFloat32
   833  }
   834  
   835  func (self *_Assembler) range_single_X0() {
   836      self.Emit("CVTSD2SS", _VAR_st_Dv, _X0)              // CVTSD2SS _VAR_st_Dv, X0
   837      self.Emit("MOVQ"    , _V_max_f32, _CX)              // MOVQ     _max_f32, CX
   838      self.Emit("MOVQ"    , jit.Gitab(_I_float32), _ET)   // MOVQ     ${itab(float32)}, ET
   839      self.Emit("MOVQ"    , jit.Gtype(_T_float32), _EP)   // MOVQ     ${type(float32)}, EP
   840      self.Emit("UCOMISS" , jit.Ptr(_CX, 0), _X0)         // UCOMISS  (CX), X0
   841      self.Sjmp("JA"      , _LB_range_error)              // JA       _range_error
   842      self.Emit("MOVQ"    , _V_min_f32, _CX)              // MOVQ     _min_f32, CX
   843      self.Emit("UCOMISS" , jit.Ptr(_CX, 0), _X0)         // UCOMISS  (CX), X0
   844      self.Sjmp("JB"      , _LB_range_error)              // JB      _range_error
   845  }
   846  
   847  func (self *_Assembler) range_signed_CX(i *rt.GoItab, t *rt.GoType, a int64, b int64) {
   848      self.Emit("MOVQ", _VAR_st_Iv, _CX)      // MOVQ st.Iv, CX
   849      self.Emit("MOVQ", jit.Gitab(i), _ET)    // MOVQ ${i}, ET
   850      self.Emit("MOVQ", jit.Gtype(t), _EP)    // MOVQ ${t}, EP
   851      self.Emit("CMPQ", _CX, jit.Imm(a))      // CMPQ CX, ${a}
   852      self.Sjmp("JL"  , _LB_range_error)      // JL   _range_error
   853      self.Emit("CMPQ", _CX, jit.Imm(b))      // CMPQ CX, ${B}
   854      self.Sjmp("JG"  , _LB_range_error)      // JG   _range_error
   855  }
   856  
   857  func (self *_Assembler) range_unsigned_CX(i *rt.GoItab, t *rt.GoType, v uint64) {
   858      self.Emit("MOVQ" , _VAR_st_Iv, _CX)         // MOVQ  st.Iv, CX
   859      self.Emit("MOVQ" , jit.Gitab(i), _ET)       // MOVQ  ${i}, ET
   860      self.Emit("MOVQ" , jit.Gtype(t), _EP)       // MOVQ  ${t}, EP
   861      self.Emit("TESTQ", _CX, _CX)                // TESTQ CX, CX
   862      self.Sjmp("JS"   , _LB_range_error)         // JS    _range_error
   863      self.Emit("CMPQ" , _CX, jit.Imm(int64(v)))  // CMPQ  CX, ${a}
   864      self.Sjmp("JA"   , _LB_range_error)         // JA    _range_error
   865  }
   866  
   867  /** String Manipulating Routines **/
   868  
   869  var (
   870      _F_unquote = jit.Imm(int64(native.S_unquote))
   871  )
   872  
   873  func (self *_Assembler) slice_from(p obj.Addr, d int64) {
   874      self.Emit("MOVQ", p, _SI)   // MOVQ    ${p}, SI
   875      self.slice_from_r(_SI, d)   // SLICE_R SI, ${d}
   876  }
   877  
   878  func (self *_Assembler) slice_from_r(p obj.Addr, d int64) {
   879      self.Emit("LEAQ", jit.Sib(_IP, p, 1, 0), _DI)   // LEAQ (IP)(${p}), DI
   880      self.Emit("NEGQ", p)                            // NEGQ ${p}
   881      self.Emit("LEAQ", jit.Sib(_IC, p, 1, d), _SI)   // LEAQ d(IC)(${p}), SI
   882  }
   883  
   884  func (self *_Assembler) unquote_once(p obj.Addr, n obj.Addr, stack bool, copy bool) {
   885      self.slice_from(_VAR_st_Iv, -1)                             // SLICE  st.Iv, $-1
   886      self.Emit("CMPQ", _VAR_st_Ep, jit.Imm(-1))                 // CMPQ   st.Ep, $-1
   887      self.Sjmp("JE"  , "_noescape_{n}")                         // JE     _escape_{n}
   888      self.Byte(0x4c, 0x8d, 0x0d)         // LEAQ (PC), R9
   889      self.Sref("_unquote_once_write_{n}", 4)
   890      self.Sjmp("JMP" , "_escape_string")
   891      self.Link("_noescape_{n}")
   892      if copy {
   893          self.Emit("BTQ" , jit.Imm(_F_copy_string), _ARG_fv)    
   894          self.Sjmp("JNC", "_unquote_once_write_{n}")
   895          self.Byte(0x4c, 0x8d, 0x0d)         // LEAQ (PC), R9
   896          self.Sref("_unquote_once_write_{n}", 4)
   897          self.Sjmp("JMP", "_copy_string")
   898      }
   899      self.Link("_unquote_once_write_{n}")
   900      self.Emit("MOVQ", _SI, n)                                  // MOVQ   SI, ${n}
   901      if stack {
   902          self.Emit("MOVQ", _DI, p) 
   903      } else {
   904          self.WriteRecNotAX(10, _DI, p, false, false)
   905      }
   906  }
   907  
   908  func (self *_Assembler) unquote_twice(p obj.Addr, n obj.Addr, stack bool) {
   909      self.Emit("CMPQ" , _VAR_st_Ep, jit.Imm(-1))                     // CMPQ   st.Ep, $-1
   910      self.Sjmp("JE"   , _LB_eof_error)                               // JE     _eof_error
   911      self.Emit("CMPB" , jit.Sib(_IP, _IC, 1, -3), jit.Imm('\\'))     // CMPB   -3(IP)(IC), $'\\'
   912      self.Sjmp("JNE"  , _LB_char_m3_error)                           // JNE    _char_m3_error
   913      self.Emit("CMPB" , jit.Sib(_IP, _IC, 1, -2), jit.Imm('"'))      // CMPB   -2(IP)(IC), $'"'
   914      self.Sjmp("JNE"  , _LB_char_m2_error)                           // JNE    _char_m2_error
   915      self.slice_from(_VAR_st_Iv, -3)                                 // SLICE  st.Iv, $-3
   916      self.Emit("MOVQ" , _SI, _AX)                                    // MOVQ   SI, AX
   917      self.Emit("ADDQ" , _VAR_st_Iv, _AX)                             // ADDQ   st.Iv, AX
   918      self.Emit("CMPQ" , _VAR_st_Ep, _AX)                             // CMPQ   st.Ep, AX
   919      self.Sjmp("JE"   , "_noescape_{n}")                             // JE     _noescape_{n}
   920      self.Byte(0x4c, 0x8d, 0x0d)         // LEAQ (PC), R9
   921      self.Sref("_unquote_twice_write_{n}", 4)
   922      self.Sjmp("JMP" , "_escape_string_twice")
   923      self.Link("_noescape_{n}")                                      // _noescape_{n}:
   924      self.Emit("BTQ"  , jit.Imm(_F_copy_string), _ARG_fv)    
   925      self.Sjmp("JNC", "_unquote_twice_write_{n}") 
   926      self.Byte(0x4c, 0x8d, 0x0d)         // LEAQ (PC), R9
   927      self.Sref("_unquote_twice_write_{n}", 4)
   928      self.Sjmp("JMP", "_copy_string")
   929      self.Link("_unquote_twice_write_{n}")
   930      self.Emit("MOVQ" , _SI, n)                                      // MOVQ   SI, ${n}
   931      if stack {
   932          self.Emit("MOVQ", _DI, p) 
   933      } else {
   934          self.WriteRecNotAX(12, _DI, p, false, false)
   935      }
   936      self.Link("_unquote_twice_end_{n}")
   937  }
   938  
   939  /** Memory Clearing Routines **/
   940  
   941  var (
   942      _F_memclrHasPointers    = jit.Func(memclrHasPointers)
   943      _F_memclrNoHeapPointers = jit.Func(memclrNoHeapPointers)
   944  )
   945  
   946  func (self *_Assembler) mem_clear_fn(ptrfree bool) {
   947      if !ptrfree {
   948          self.call_go(_F_memclrHasPointers)
   949      } else {
   950          self.call_go(_F_memclrNoHeapPointers)
   951      }
   952  }
   953  
   954  func (self *_Assembler) mem_clear_rem(size int64, ptrfree bool) {
   955      self.Emit("MOVQ", jit.Imm(size), _BX)               // MOVQ    ${size}, BX
   956      self.Emit("MOVQ", jit.Ptr(_ST, 0), _AX)             // MOVQ    (ST), AX
   957      self.Emit("MOVQ", jit.Sib(_ST, _AX, 1, 0), _AX)     // MOVQ    (ST)(AX), AX
   958      self.Emit("SUBQ", _VP, _AX)                         // SUBQ    VP, AX
   959      self.Emit("ADDQ", _AX, _BX)                         // ADDQ    AX, BX
   960      self.Emit("MOVQ", _VP, _AX)                         // MOVQ    VP, (SP)
   961      self.mem_clear_fn(ptrfree)                          // CALL_GO memclr{Has,NoHeap}Pointers
   962  }
   963  
   964  /** Map Assigning Routines **/
   965  
   966  var (
   967      _F_mapassign           = jit.Func(mapassign)
   968      _F_mapassign_fast32    = jit.Func(mapassign_fast32)
   969      _F_mapassign_faststr   = jit.Func(mapassign_faststr)
   970      _F_mapassign_fast64ptr = jit.Func(mapassign_fast64ptr)
   971  )
   972  
   973  var (
   974      _F_decodeJsonUnmarshaler obj.Addr
   975      _F_decodeTextUnmarshaler obj.Addr
   976  )
   977  
   978  func init() {
   979      _F_decodeJsonUnmarshaler = jit.Func(decodeJsonUnmarshaler)
   980      _F_decodeTextUnmarshaler = jit.Func(decodeTextUnmarshaler)
   981  }
   982  
   983  func (self *_Assembler) mapaccess_ptr(t reflect.Type) {
   984      if rt.MapType(rt.UnpackType(t)).IndirectElem() {
   985          self.vfollow(t.Elem())
   986      }
   987  }
   988  
   989  func (self *_Assembler) mapassign_std(t reflect.Type, v obj.Addr) {
   990      self.Emit("LEAQ", v, _AX)               // LEAQ      ${v}, AX
   991      self.mapassign_call_from_AX(t, _F_mapassign)    // MAPASSIGN ${t}, mapassign
   992  }
   993  
   994  func (self *_Assembler) mapassign_str_fast(t reflect.Type, p obj.Addr, n obj.Addr) {
   995      self.Emit("MOVQ", jit.Type(t), _AX)         // MOVQ    ${t}, AX
   996      self.Emit("MOVQ", _VP, _BX)                 // MOVQ    VP, BX
   997      self.Emit("MOVQ", p, _CX)                   // MOVQ    ${p}, CX
   998      self.Emit("MOVQ", n, _DI)                   // MOVQ    ${n}, DI
   999      self.call_go(_F_mapassign_faststr)          // CALL_GO ${fn}
  1000      self.Emit("MOVQ", _AX, _VP)                 // MOVQ    AX, VP
  1001      self.mapaccess_ptr(t)
  1002  }
  1003  
  1004  func (self *_Assembler) mapassign_call_from_AX(t reflect.Type, fn obj.Addr) {
  1005      self.Emit("MOVQ", _AX, _CX)
  1006      self.Emit("MOVQ", jit.Type(t), _AX)         // MOVQ    ${t}, AX
  1007      self.Emit("MOVQ", _VP, _BX)                 // MOVQ    VP, _BX
  1008      self.call_go(fn)                            // CALL_GO ${fn}
  1009      self.Emit("MOVQ", _AX, _VP)                 // MOVQ    AX, VP
  1010  }
  1011  
  1012  func (self *_Assembler) mapassign_fastx(t reflect.Type, fn obj.Addr) {
  1013      self.mapassign_call_from_AX(t, fn)
  1014      self.mapaccess_ptr(t)
  1015  }
  1016  
  1017  func (self *_Assembler) mapassign_utext(t reflect.Type, addressable bool) {
  1018      pv := false
  1019      vk := t.Key()
  1020      tk := t.Key()
  1021  
  1022      /* deref pointer if needed */
  1023      if vk.Kind() == reflect.Ptr {
  1024          pv = true
  1025          vk = vk.Elem()
  1026      }
  1027  
  1028      /* addressable value with pointer receiver */
  1029      if addressable {
  1030          pv = false
  1031          tk = reflect.PtrTo(tk)
  1032      }
  1033  
  1034      /* allocate the key, and call the unmarshaler */
  1035      self.valloc(vk, _BX)                        // VALLOC  ${vk}, BX
  1036      // must spill vk pointer since next call_go may invoke GC
  1037      self.Emit("MOVQ" , _BX, _ARG_vk)
  1038      self.Emit("MOVQ" , jit.Type(tk), _AX)       // MOVQ    ${tk}, AX
  1039      self.Emit("MOVQ" , _ARG_sv_p, _CX)          // MOVQ    sv.p, CX
  1040      self.Emit("MOVQ" , _ARG_sv_n, _DI)          // MOVQ    sv.n, DI
  1041      self.call_go(_F_decodeTextUnmarshaler)      // CALL_GO decodeTextUnmarshaler
  1042      self.Emit("TESTQ", _ET, _ET)                // TESTQ   ET, ET
  1043      self.Sjmp("JNZ"  , _LB_error)               // JNZ     _error
  1044      self.Emit("MOVQ" , _ARG_vk, _AX)            // MOVQ    VAR.vk, AX
  1045      self.Emit("MOVQ", jit.Imm(0), _ARG_vk)
  1046  
  1047      /* select the correct assignment function */
  1048      if !pv {
  1049          self.mapassign_call_from_AX(t, _F_mapassign)
  1050      } else {
  1051          self.mapassign_fastx(t, _F_mapassign_fast64ptr)
  1052      }
  1053  }
  1054  
  1055  /** External Unmarshaler Routines **/
  1056  
  1057  var (
  1058      _F_skip_one = jit.Imm(int64(native.S_skip_one))
  1059      _F_skip_array  = jit.Imm(int64(native.S_skip_array))
  1060      _F_skip_object = jit.Imm(int64(native.S_skip_object))
  1061      _F_skip_number = jit.Imm(int64(native.S_skip_number))
  1062  )
  1063  
  1064  func (self *_Assembler) unmarshal_json(t reflect.Type, deref bool) {
  1065      self.call_sf(_F_skip_one)                                   // CALL_SF   skip_one
  1066      self.Emit("TESTQ", _AX, _AX)                                // TESTQ     AX, AX
  1067      self.Sjmp("JS"   , _LB_parsing_error_v)                     // JS        _parse_error_v
  1068      self.slice_from_r(_AX, 0)                                   // SLICE_R   AX, $0
  1069      self.Emit("MOVQ" , _DI, _ARG_sv_p)                          // MOVQ      DI, sv.p
  1070      self.Emit("MOVQ" , _SI, _ARG_sv_n)                          // MOVQ      SI, sv.n
  1071      self.unmarshal_func(t, _F_decodeJsonUnmarshaler, deref)     // UNMARSHAL json, ${t}, ${deref}
  1072  }
  1073  
  1074  func (self *_Assembler) unmarshal_text(t reflect.Type, deref bool) {
  1075      self.parse_string()                                         // PARSE     STRING
  1076      self.unquote_once(_ARG_sv_p, _ARG_sv_n, true, true)        // UNQUOTE   once, sv.p, sv.n
  1077      self.unmarshal_func(t, _F_decodeTextUnmarshaler, deref)     // UNMARSHAL text, ${t}, ${deref}
  1078  }
  1079  
  1080  func (self *_Assembler) unmarshal_func(t reflect.Type, fn obj.Addr, deref bool) {
  1081      pt := t
  1082      vk := t.Kind()
  1083  
  1084      /* allocate the field if needed */
  1085      if deref && vk == reflect.Ptr {
  1086          self.Emit("MOVQ" , _VP, _BX)                // MOVQ   VP, BX
  1087          self.Emit("MOVQ" , jit.Ptr(_BX, 0), _BX)    // MOVQ   (BX), BX
  1088          self.Emit("TESTQ", _BX, _BX)                // TESTQ  BX, BX
  1089          self.Sjmp("JNZ"  , "_deref_{n}")            // JNZ    _deref_{n}
  1090          self.valloc(t.Elem(), _BX)                  // VALLOC ${t.Elem()}, BX
  1091          self.WriteRecNotAX(3, _BX, jit.Ptr(_VP, 0), false, false)    // MOVQ   BX, (VP)
  1092          self.Link("_deref_{n}")                     // _deref_{n}:
  1093      } else {
  1094          /* set value pointer */
  1095          self.Emit("MOVQ", _VP, _BX)                 // MOVQ   (VP), BX
  1096      }
  1097  
  1098      /* set value type */
  1099      self.Emit("MOVQ", jit.Type(pt), _AX)        // MOVQ ${pt}, AX
  1100  
  1101      /* set the source string and call the unmarshaler */
  1102      self.Emit("MOVQ" , _ARG_sv_p, _CX)          // MOVQ    sv.p, CX
  1103      self.Emit("MOVQ" , _ARG_sv_n, _DI)          // MOVQ    sv.n, DI
  1104      self.call_go(fn)                            // CALL_GO ${fn}
  1105      self.Emit("TESTQ", _ET, _ET)                // TESTQ   ET, ET
  1106      self.Sjmp("JNZ"  , _LB_error)               // JNZ     _error
  1107  }
  1108  
  1109  /** Dynamic Decoding Routine **/
  1110  
  1111  var (
  1112      _F_decodeTypedPointer obj.Addr
  1113  )
  1114  
  1115  func init() {
  1116      _F_decodeTypedPointer = jit.Func(decodeTypedPointer)
  1117  }
  1118  
  1119  func (self *_Assembler) decode_dynamic(vt obj.Addr, vp obj.Addr) {
  1120      self.Emit("MOVQ" , vp, _SI)    // MOVQ    ${vp}, SI
  1121      self.Emit("MOVQ" , vt, _DI)    // MOVQ    ${vt}, DI
  1122      self.Emit("MOVQ", _ARG_sp, _AX)            // MOVQ    sp, AX
  1123      self.Emit("MOVQ", _ARG_sl, _BX)            // MOVQ    sp, BX
  1124      self.Emit("MOVQ" , _IC, _CX)                // MOVQ    IC, CX
  1125      self.Emit("MOVQ" , _ST, _R8)                // MOVQ    ST, R8 
  1126      self.Emit("MOVQ" , _ARG_fv, _R9)            // MOVQ    fv, R9
  1127      self.save(_REG_rt...)
  1128      self.Emit("MOVQ", _F_decodeTypedPointer, _IL)  // MOVQ ${fn}, R11
  1129      self.Rjmp("CALL", _IL)      // CALL R11
  1130      self.load(_REG_rt...)
  1131      self.Emit("MOVQ" , _AX, _IC)                // MOVQ    AX, IC
  1132      self.Emit("MOVQ" , _BX, _ET)                // MOVQ    BX, ET
  1133      self.Emit("MOVQ" , _CX, _EP)                // MOVQ    CX, EP
  1134      self.Emit("TESTQ", _ET, _ET)                // TESTQ   ET, ET
  1135      self.Sjmp("JE", "_decode_dynamic_end_{n}")  // JE, _decode_dynamic_end_{n}
  1136      self.Emit("MOVQ", _I_json_MismatchTypeError, _CX) // MOVQ _I_json_MismatchTypeError, CX
  1137      self.Emit("CMPQ", _ET, _CX)                 // CMPQ ET, CX
  1138      self.Sjmp("JNE",  _LB_error)                // JNE  LB_error
  1139      self.Emit("MOVQ", _EP, _VAR_ic)             // MOVQ EP, VAR_ic
  1140      self.Emit("MOVQ", _ET, _VAR_et)             // MOVQ ET, VAR_et
  1141      self.Link("_decode_dynamic_end_{n}")
  1142  }
  1143  
  1144  /** OpCode Assembler Functions **/
  1145  
  1146  var (
  1147      _F_memequal         = jit.Func(memequal)
  1148      _F_memmove          = jit.Func(memmove)
  1149      _F_growslice        = jit.Func(growslice)
  1150      _F_makeslice        = jit.Func(makeslice)
  1151      _F_makemap_small    = jit.Func(makemap_small)
  1152      _F_mapassign_fast64 = jit.Func(mapassign_fast64)
  1153  )
  1154  
  1155  var (
  1156      _F_lspace  = jit.Imm(int64(native.S_lspace))
  1157      _F_strhash = jit.Imm(int64(caching.S_strhash))
  1158  )
  1159  
  1160  var (
  1161      _F_b64decode   = jit.Imm(int64(_subr__b64decode))
  1162      _F_decodeValue = jit.Imm(int64(_subr_decode_value))
  1163  )
  1164  
  1165  var (
  1166      _F_FieldMap_GetCaseInsensitive obj.Addr
  1167      _Empty_Slice = []byte{}
  1168      _Zero_Base = int64(uintptr(((*rt.GoSlice)(unsafe.Pointer(&_Empty_Slice))).Ptr))
  1169  )
  1170  
  1171  const (
  1172      _MODE_AVX2 = 1 << 2
  1173  )
  1174  
  1175  const (
  1176      _Fe_ID   = int64(unsafe.Offsetof(caching.FieldEntry{}.ID))
  1177      _Fe_Name = int64(unsafe.Offsetof(caching.FieldEntry{}.Name))
  1178      _Fe_Hash = int64(unsafe.Offsetof(caching.FieldEntry{}.Hash))
  1179  )
  1180  
  1181  const (
  1182      _Vk_Ptr       = int64(reflect.Ptr)
  1183      _Gt_KindFlags = int64(unsafe.Offsetof(rt.GoType{}.KindFlags))
  1184  )
  1185  
  1186  func init() {
  1187      _F_FieldMap_GetCaseInsensitive = jit.Func((*caching.FieldMap).GetCaseInsensitive)
  1188  }
  1189  
  1190  func (self *_Assembler) _asm_OP_any(_ *_Instr) {
  1191      self.Emit("MOVQ"   , jit.Ptr(_VP, 8), _CX)              // MOVQ    8(VP), CX
  1192      self.Emit("TESTQ"  , _CX, _CX)                          // TESTQ   CX, CX
  1193      self.Sjmp("JZ"     , "_decode_{n}")                     // JZ      _decode_{n}
  1194      self.Emit("CMPQ"   , _CX, _VP)                          // CMPQ    CX, VP
  1195      self.Sjmp("JE"     , "_decode_{n}")                     // JE      _decode_{n}
  1196      self.Emit("MOVQ"   , jit.Ptr(_VP, 0), _AX)              // MOVQ    (VP), AX
  1197      self.Emit("MOVBLZX", jit.Ptr(_AX, _Gt_KindFlags), _DX)  // MOVBLZX _Gt_KindFlags(AX), DX
  1198      self.Emit("ANDL"   , jit.Imm(rt.F_kind_mask), _DX)      // ANDL    ${F_kind_mask}, DX
  1199      self.Emit("CMPL"   , _DX, jit.Imm(_Vk_Ptr))             // CMPL    DX, ${reflect.Ptr}
  1200      self.Sjmp("JNE"    , "_decode_{n}")                     // JNE     _decode_{n}
  1201      self.Emit("LEAQ"   , jit.Ptr(_VP, 8), _DI)              // LEAQ    8(VP), DI
  1202      self.decode_dynamic(_AX, _DI)                           // DECODE  AX, DI
  1203      self.Sjmp("JMP"    , "_decode_end_{n}")                 // JMP     _decode_end_{n}
  1204      self.Link("_decode_{n}")                                // _decode_{n}:
  1205      self.Emit("MOVQ"   , _ARG_fv, _DF)                      // MOVQ    fv, DF
  1206      self.Emit("MOVQ"   , _ST, jit.Ptr(_SP, 0))              // MOVQ    _ST, (SP)
  1207      self.call(_F_decodeValue)                               // CALL    decodeValue
  1208      self.Emit("MOVQ"   , jit.Imm(0), jit.Ptr(_SP, 0))              // MOVQ    _ST, (SP)
  1209      self.Emit("TESTQ"  , _EP, _EP)                          // TESTQ   EP, EP
  1210      self.Sjmp("JNZ"    , _LB_parsing_error)                 // JNZ     _parsing_error
  1211      self.Link("_decode_end_{n}")                            // _decode_end_{n}:
  1212  }
  1213  
  1214  func (self *_Assembler) _asm_OP_dyn(p *_Instr) {
  1215      self.Emit("MOVQ"   , jit.Type(p.vt()), _ET)             // MOVQ    ${p.vt()}, ET
  1216      self.Emit("CMPQ"   , jit.Ptr(_VP, 8), jit.Imm(0))       // CMPQ    8(VP), $0
  1217      self.Sjmp("JE"     , _LB_type_error)                    // JE      _type_error
  1218      self.Emit("MOVQ"   , jit.Ptr(_VP, 0), _CX)              // MOVQ    (VP), CX
  1219      self.Emit("MOVQ"   , jit.Ptr(_CX, 8), _CX)              // MOVQ    8(CX), CX
  1220      self.Emit("MOVBLZX", jit.Ptr(_CX, _Gt_KindFlags), _DX)  // MOVBLZX _Gt_KindFlags(CX), DX
  1221      self.Emit("ANDL"   , jit.Imm(rt.F_kind_mask), _DX)      // ANDL    ${F_kind_mask}, DX
  1222      self.Emit("CMPL"   , _DX, jit.Imm(_Vk_Ptr))             // CMPL    DX, ${reflect.Ptr}
  1223      self.Sjmp("JNE"    , _LB_type_error)                    // JNE     _type_error
  1224      self.Emit("LEAQ"   , jit.Ptr(_VP, 8), _DI)              // LEAQ    8(VP), DI
  1225      self.decode_dynamic(_CX, _DI)                           // DECODE  CX, DI
  1226      self.Link("_decode_end_{n}")                            // _decode_end_{n}:
  1227  }
  1228  
  1229  func (self *_Assembler) _asm_OP_str(_ *_Instr) {
  1230      self.parse_string()                                     // PARSE   STRING
  1231      self.unquote_once(jit.Ptr(_VP, 0), jit.Ptr(_VP, 8), false, true)     // UNQUOTE once, (VP), 8(VP)
  1232  }
  1233  
  1234  func (self *_Assembler) _asm_OP_bin(_ *_Instr) {
  1235      self.parse_string()                                 // PARSE  STRING
  1236      self.slice_from(_VAR_st_Iv, -1)                     // SLICE  st.Iv, $-1
  1237      self.Emit("MOVQ" , _DI, jit.Ptr(_VP, 0))            // MOVQ   DI, (VP)
  1238      self.Emit("MOVQ" , _SI, jit.Ptr(_VP, 8))            // MOVQ   SI, 8(VP)
  1239      self.Emit("SHRQ" , jit.Imm(2), _SI)                 // SHRQ   $2, SI
  1240      self.Emit("LEAQ" , jit.Sib(_SI, _SI, 2, 0), _SI)    // LEAQ   (SI)(SI*2), SI
  1241      self.Emit("MOVQ" , _SI, jit.Ptr(_VP, 16))           // MOVQ   SI, 16(VP)
  1242      self.malloc_AX(_SI, _SI)                               // MALLOC SI, SI
  1243  
  1244      // TODO: due to base64x's bug, only use AVX mode now
  1245      self.Emit("MOVL", jit.Imm(_MODE_JSON), _CX)          //  MOVL $_MODE_JSON, CX
  1246  
  1247      /* call the decoder */
  1248      self.Emit("XORL" , _DX, _DX)                // XORL  DX, DX
  1249      self.Emit("MOVQ" , _VP, _DI)                // MOVQ  VP, DI
  1250  
  1251      self.Emit("MOVQ" , jit.Ptr(_VP, 0), _R8)    // MOVQ SI, （VP)
  1252      self.WriteRecNotAX(4, _SI, jit.Ptr(_VP, 0), true, false)    // XCHGQ SI, (VP) 
  1253      self.Emit("MOVQ" , _R8, _SI)
  1254  
  1255      self.Emit("XCHGQ", _DX, jit.Ptr(_VP, 8))    // XCHGQ DX, 8(VP)
  1256      self.call_c(_F_b64decode)                     // CALL  b64decode
  1257      self.Emit("TESTQ", _AX, _AX)                // TESTQ AX, AX
  1258      self.Sjmp("JS"   , _LB_base64_error)        // JS    _base64_error
  1259      self.Emit("MOVQ" , _AX, jit.Ptr(_VP, 8))    // MOVQ  AX, 8(VP)
  1260  }
  1261  
  1262  func (self *_Assembler) _asm_OP_bool(_ *_Instr) {
  1263      self.Emit("LEAQ", jit.Ptr(_IC, 4), _AX)                     // LEAQ 4(IC), AX
  1264      self.Emit("CMPQ", _AX, _IL)                                 // CMPQ AX, IL
  1265      self.Sjmp("JA"  , _LB_eof_error)                            // JA   _eof_error
  1266      self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm('f'))    // CMPB (IP)(IC), $'f'
  1267      self.Sjmp("JE"  , "_false_{n}")                             // JE   _false_{n}
  1268      self.Emit("MOVL", jit.Imm(_IM_true), _CX)                   // MOVL $"true", CX
  1269      self.Emit("CMPL", _CX, jit.Sib(_IP, _IC, 1, 0))             // CMPL CX, (IP)(IC)
  1270      self.Sjmp("JE" , "_bool_true_{n}")          
  1271      // try to skip the value
  1272      self.Emit("MOVQ", _IC, _VAR_ic)           
  1273      self.Emit("MOVQ", _T_bool, _ET)     
  1274      self.Emit("MOVQ", _ET, _VAR_et)
  1275      self.Byte(0x4c, 0x8d, 0x0d)         // LEAQ (PC), R9
  1276      self.Sref("_end_{n}", 4)
  1277      self.Emit("MOVQ", _R9, _VAR_pc)
  1278      self.Sjmp("JMP"  , _LB_skip_one) 
  1279  
  1280      self.Link("_bool_true_{n}")
  1281      self.Emit("MOVQ", _AX, _IC)                                 // MOVQ AX, IC
  1282      self.Emit("MOVB", jit.Imm(1), jit.Ptr(_VP, 0))              // MOVB $1, (VP)
  1283      self.Sjmp("JMP" , "_end_{n}")                               // JMP  _end_{n}
  1284      self.Link("_false_{n}")                                     // _false_{n}:
  1285      self.Emit("ADDQ", jit.Imm(1), _AX)                          // ADDQ $1, AX
  1286      self.Emit("ADDQ", jit.Imm(1), _IC)                          // ADDQ $1, IC
  1287      self.Emit("CMPQ", _AX, _IL)                                 // CMPQ AX, IL
  1288      self.Sjmp("JA"  , _LB_eof_error)                            // JA   _eof_error
  1289      self.Emit("MOVL", jit.Imm(_IM_alse), _CX)                   // MOVL $"alse", CX
  1290      self.Emit("CMPL", _CX, jit.Sib(_IP, _IC, 1, 0))             // CMPL CX, (IP)(IC)
  1291      self.Sjmp("JNE" , _LB_im_error)                             // JNE  _im_error
  1292      self.Emit("MOVQ", _AX, _IC)                                 // MOVQ AX, IC
  1293      self.Emit("XORL", _AX, _AX)                                 // XORL AX, AX
  1294      self.Emit("MOVB", _AX, jit.Ptr(_VP, 0))                     // MOVB AX, (VP)
  1295      self.Link("_end_{n}")                                       // _end_{n}:
  1296  }
  1297  
  1298  func (self *_Assembler) _asm_OP_num(_ *_Instr) {
  1299      self.Emit("MOVQ", jit.Imm(0), _VAR_fl)
  1300      self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm('"'))
  1301      self.Emit("MOVQ", _IC, _BX)
  1302      self.Sjmp("JNE", "_skip_number_{n}")
  1303      self.Emit("MOVQ", jit.Imm(1), _VAR_fl)
  1304      self.Emit("ADDQ", jit.Imm(1), _IC)
  1305      self.Link("_skip_number_{n}")
  1306  
  1307      /* call skip_number */
  1308      self.Emit("LEAQ", _ARG_s, _DI)                      // LEAQ  s<>+0(FP), DI
  1309      self.Emit("MOVQ", _IC, _ARG_ic)                     // MOVQ  IC, ic<>+16(FP)
  1310      self.Emit("LEAQ", _ARG_ic, _SI)                     // LEAQ  ic<>+16(FP), SI
  1311      self.callc(_F_skip_number)                          // CALL  _F_skip_number
  1312      self.Emit("MOVQ", _ARG_ic, _IC)                     // MOVQ  ic<>+16(FP), IC
  1313      self.Emit("TESTQ", _AX, _AX)                        // TESTQ AX, AX
  1314      self.Sjmp("JNS"   , "_num_next_{n}")
  1315  
  1316      /* call skip one */
  1317      self.Emit("MOVQ", _BX, _VAR_ic)           
  1318      self.Emit("MOVQ", _T_number, _ET)     
  1319      self.Emit("MOVQ", _ET, _VAR_et)
  1320      self.Byte(0x4c, 0x8d, 0x0d)       
  1321      self.Sref("_num_end_{n}", 4)
  1322      self.Emit("MOVQ", _R9, _VAR_pc)
  1323      self.Sjmp("JMP"  , _LB_skip_one)
  1324  
  1325      /* assgin string */
  1326      self.Link("_num_next_{n}")
  1327      self.slice_from_r(_AX, 0)
  1328      self.Emit("BTQ", jit.Imm(_F_copy_string), _ARG_fv)
  1329      self.Sjmp("JNC", "_num_write_{n}")
  1330      self.Byte(0x4c, 0x8d, 0x0d)         // LEAQ (PC), R9
  1331      self.Sref("_num_write_{n}", 4)
  1332      self.Sjmp("JMP", "_copy_string")
  1333      self.Link("_num_write_{n}")
  1334      self.Emit("MOVQ", _SI, jit.Ptr(_VP, 8))     // MOVQ  SI, 8(VP)
  1335      self.WriteRecNotAX(13, _DI, jit.Ptr(_VP, 0), false, false)
  1336      self.Emit("CMPQ", _VAR_fl, jit.Imm(1))
  1337      self.Sjmp("JNE", "_num_end_{n}")
  1338      self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm('"'))
  1339      self.Sjmp("JNE", _LB_char_0_error)
  1340      self.Emit("ADDQ", jit.Imm(1), _IC)
  1341      self.Link("_num_end_{n}")
  1342  }
  1343  
  1344  func (self *_Assembler) _asm_OP_i8(_ *_Instr) {
  1345      var pin = "_i8_end_{n}"
  1346      self.parse_signed(int8Type, pin, -1)                                                 // PARSE int8
  1347      self.range_signed_CX(_I_int8, _T_int8, math.MinInt8, math.MaxInt8)     // RANGE int8
  1348      self.Emit("MOVB", _CX, jit.Ptr(_VP, 0))                             // MOVB  CX, (VP)
  1349      self.Link(pin)
  1350  }
  1351  
  1352  func (self *_Assembler) _asm_OP_i16(_ *_Instr) {
  1353      var pin = "_i16_end_{n}"
  1354      self.parse_signed(int16Type, pin, -1)                                                     // PARSE int16
  1355      self.range_signed_CX(_I_int16, _T_int16, math.MinInt16, math.MaxInt16)     // RANGE int16
  1356      self.Emit("MOVW", _CX, jit.Ptr(_VP, 0))                                 // MOVW  CX, (VP)
  1357      self.Link(pin)
  1358  }
  1359  
  1360  func (self *_Assembler) _asm_OP_i32(_ *_Instr) {
  1361      var pin = "_i32_end_{n}"
  1362      self.parse_signed(int32Type, pin, -1)                                                     // PARSE int32
  1363      self.range_signed_CX(_I_int32, _T_int32, math.MinInt32, math.MaxInt32)     // RANGE int32
  1364      self.Emit("MOVL", _CX, jit.Ptr(_VP, 0))                                 // MOVL  CX, (VP)
  1365      self.Link(pin)
  1366  }
  1367  
  1368  func (self *_Assembler) _asm_OP_i64(_ *_Instr) {
  1369      var pin = "_i64_end_{n}"
  1370      self.parse_signed(int64Type, pin, -1)                         // PARSE int64
  1371      self.Emit("MOVQ", _VAR_st_Iv, _AX)          // MOVQ  st.Iv, AX
  1372      self.Emit("MOVQ", _AX, jit.Ptr(_VP, 0))     // MOVQ  AX, (VP)
  1373      self.Link(pin)
  1374  }
  1375  
  1376  func (self *_Assembler) _asm_OP_u8(_ *_Instr) {
  1377      var pin = "_u8_end_{n}"
  1378      self.parse_unsigned(uint8Type, pin, -1)                                   // PARSE uint8
  1379      self.range_unsigned_CX(_I_uint8, _T_uint8, math.MaxUint8)  // RANGE uint8
  1380      self.Emit("MOVB", _CX, jit.Ptr(_VP, 0))                 // MOVB  CX, (VP)
  1381      self.Link(pin)
  1382  }
  1383  
  1384  func (self *_Assembler) _asm_OP_u16(_ *_Instr) {
  1385      var pin = "_u16_end_{n}"
  1386      self.parse_unsigned(uint16Type, pin, -1)                                       // PARSE uint16
  1387      self.range_unsigned_CX(_I_uint16, _T_uint16, math.MaxUint16)   // RANGE uint16
  1388      self.Emit("MOVW", _CX, jit.Ptr(_VP, 0))                     // MOVW  CX, (VP)
  1389      self.Link(pin)
  1390  }
  1391  
  1392  func (self *_Assembler) _asm_OP_u32(_ *_Instr) {
  1393      var pin = "_u32_end_{n}"
  1394      self.parse_unsigned(uint32Type, pin, -1)                                       // PARSE uint32
  1395      self.range_unsigned_CX(_I_uint32, _T_uint32, math.MaxUint32)   // RANGE uint32
  1396      self.Emit("MOVL", _CX, jit.Ptr(_VP, 0))                     // MOVL  CX, (VP)
  1397      self.Link(pin)
  1398  }
  1399  
  1400  func (self *_Assembler) _asm_OP_u64(_ *_Instr) {
  1401      var pin = "_u64_end_{n}"
  1402      self.parse_unsigned(uint64Type, pin, -1)                       // PARSE uint64
  1403      self.Emit("MOVQ", _VAR_st_Iv, _AX)          // MOVQ  st.Iv, AX
  1404      self.Emit("MOVQ", _AX, jit.Ptr(_VP, 0))     // MOVQ  AX, (VP)
  1405      self.Link(pin)
  1406  }
  1407  
  1408  func (self *_Assembler) _asm_OP_f32(_ *_Instr) {
  1409      var pin = "_f32_end_{n}"
  1410      self.parse_number(float32Type, pin, -1)                         // PARSE NUMBER
  1411      self.range_single_X0()                         // RANGE float32
  1412      self.Emit("MOVSS", _X0, jit.Ptr(_VP, 0))    // MOVSS X0, (VP)
  1413      self.Link(pin)
  1414  }
  1415  
  1416  func (self *_Assembler) _asm_OP_f64(_ *_Instr) {
  1417      var pin = "_f64_end_{n}"
  1418      self.parse_number(float64Type, pin, -1)                         // PARSE NUMBER
  1419      self.Emit("MOVSD", _VAR_st_Dv, _X0)         // MOVSD st.Dv, X0
  1420      self.Emit("MOVSD", _X0, jit.Ptr(_VP, 0))    // MOVSD X0, (VP)
  1421      self.Link(pin)
  1422  }
  1423  
  1424  func (self *_Assembler) _asm_OP_unquote(_ *_Instr) {
  1425      self.check_eof(2)
  1426      self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm('\\'))   // CMPB    (IP)(IC), $'\\'
  1427      self.Sjmp("JNE" , _LB_char_0_error)                         // JNE     _char_0_error
  1428      self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 1), jit.Imm('"'))    // CMPB    1(IP)(IC), $'"'
  1429      self.Sjmp("JNE" , _LB_char_1_error)                         // JNE     _char_1_error
  1430      self.Emit("ADDQ", jit.Imm(2), _IC)                          // ADDQ    $2, IC
  1431      self.parse_string()                                         // PARSE   STRING
  1432      self.unquote_twice(jit.Ptr(_VP, 0), jit.Ptr(_VP, 8), false)        // UNQUOTE twice, (VP), 8(VP)
  1433  }
  1434  
  1435  func (self *_Assembler) _asm_OP_nil_1(_ *_Instr) {
  1436      self.Emit("XORL", _AX, _AX)                 // XORL AX, AX
  1437      self.Emit("MOVQ", _AX, jit.Ptr(_VP, 0))     // MOVQ AX, (VP)
  1438  }
  1439  
  1440  func (self *_Assembler) _asm_OP_nil_2(_ *_Instr) {
  1441      self.Emit("PXOR" , _X0, _X0)                // PXOR  X0, X0
  1442      self.Emit("MOVOU", _X0, jit.Ptr(_VP, 0))    // MOVOU X0, (VP)
  1443  }
  1444  
  1445  func (self *_Assembler) _asm_OP_nil_3(_ *_Instr) {
  1446      self.Emit("XORL" , _AX, _AX)                // XORL  AX, AX
  1447      self.Emit("PXOR" , _X0, _X0)                // PXOR  X0, X0
  1448      self.Emit("MOVOU", _X0, jit.Ptr(_VP, 0))    // MOVOU X0, (VP)
  1449      self.Emit("MOVQ" , _AX, jit.Ptr(_VP, 16))   // MOVOU AX, 16(VP)
  1450  }
  1451  
  1452  func (self *_Assembler) _asm_OP_deref(p *_Instr) {
  1453      self.vfollow(p.vt())
  1454  }
  1455  
  1456  func (self *_Assembler) _asm_OP_index(p *_Instr) {
  1457      self.Emit("MOVQ", jit.Imm(p.i64()), _AX)    // MOVQ ${p.vi()}, AX
  1458      self.Emit("ADDQ", _AX, _VP)                 // ADDQ _AX, _VP
  1459  }
  1460  
  1461  func (self *_Assembler) _asm_OP_is_null(p *_Instr) {
  1462      self.Emit("LEAQ"   , jit.Ptr(_IC, 4), _AX)                          // LEAQ    4(IC), AX
  1463      self.Emit("CMPQ"   , _AX, _IL)                                      // CMPQ    AX, IL
  1464      self.Sjmp("JA"     , "_not_null_{n}")                               // JA      _not_null_{n}
  1465      self.Emit("CMPL"   , jit.Sib(_IP, _IC, 1, 0), jit.Imm(_IM_null))    // CMPL    (IP)(IC), $"null"
  1466      self.Emit("CMOVQEQ", _AX, _IC)                                      // CMOVQEQ AX, IC
  1467      self.Xjmp("JE"     , p.vi())                                        // JE      {p.vi()}
  1468      self.Link("_not_null_{n}")                                          // _not_null_{n}:
  1469  }
  1470  
  1471  func (self *_Assembler) _asm_OP_is_null_quote(p *_Instr) {
  1472      self.Emit("LEAQ"   , jit.Ptr(_IC, 5), _AX)                          // LEAQ    4(IC), AX
  1473      self.Emit("CMPQ"   , _AX, _IL)                                      // CMPQ    AX, IL
  1474      self.Sjmp("JA"     , "_not_null_quote_{n}")                         // JA      _not_null_quote_{n}
  1475      self.Emit("CMPL"   , jit.Sib(_IP, _IC, 1, 0), jit.Imm(_IM_null))    // CMPL    (IP)(IC), $"null"
  1476      self.Sjmp("JNE"    , "_not_null_quote_{n}")                         // JNE     _not_null_quote_{n}
  1477      self.Emit("CMPB"   , jit.Sib(_IP, _IC, 1, 4), jit.Imm('"'))         // CMPB    4(IP)(IC), $'"'
  1478      self.Emit("CMOVQEQ", _AX, _IC)                                      // CMOVQEQ AX, IC
  1479      self.Xjmp("JE"     , p.vi())                                        // JE      {p.vi()}
  1480      self.Link("_not_null_quote_{n}")                                    // _not_null_quote_{n}:
  1481  }
  1482  
  1483  func (self *_Assembler) _asm_OP_map_init(_ *_Instr) {
  1484      self.Emit("MOVQ" , jit.Ptr(_VP, 0), _AX)    // MOVQ    (VP), AX
  1485      self.Emit("TESTQ", _AX, _AX)                // TESTQ   AX, AX
  1486      self.Sjmp("JNZ"  , "_end_{n}")              // JNZ     _end_{n}
  1487      self.call_go(_F_makemap_small)              // CALL_GO makemap_small
  1488      self.WritePtrAX(6, jit.Ptr(_VP, 0), false)    // MOVQ    AX, (VP)
  1489      self.Link("_end_{n}")                       // _end_{n}:
  1490      self.Emit("MOVQ" , _AX, _VP)                // MOVQ    AX, VP
  1491  }
  1492  
  1493  func (self *_Assembler) _asm_OP_map_key_i8(p *_Instr) {
  1494      self.parse_signed(int8Type, "", p.vi())                                                 // PARSE     int8
  1495      self.range_signed_CX(_I_int8, _T_int8, math.MinInt8, math.MaxInt8)     // RANGE     int8
  1496      self.match_char('"')
  1497      self.mapassign_std(p.vt(), _VAR_st_Iv)                              // MAPASSIGN int8, mapassign, st.Iv
  1498  }
  1499  
  1500  func (self *_Assembler) _asm_OP_map_key_i16(p *_Instr) {
  1501      self.parse_signed(int16Type, "", p.vi())                                                     // PARSE     int16
  1502      self.range_signed_CX(_I_int16, _T_int16, math.MinInt16, math.MaxInt16)     // RANGE     int16
  1503      self.match_char('"')
  1504      self.mapassign_std(p.vt(), _VAR_st_Iv)                                  // MAPASSIGN int16, mapassign, st.Iv
  1505  }
  1506  
  1507  func (self *_Assembler) _asm_OP_map_key_i32(p *_Instr) {
  1508      self.parse_signed(int32Type, "", p.vi())                                                     // PARSE     int32
  1509      self.range_signed_CX(_I_int32, _T_int32, math.MinInt32, math.MaxInt32)     // RANGE     int32
  1510      self.match_char('"')
  1511      if vt := p.vt(); !mapfast(vt) {
  1512          self.mapassign_std(vt, _VAR_st_Iv)                                  // MAPASSIGN int32, mapassign, st.Iv
  1513      } else {
  1514          self.Emit("MOVQ", _CX, _AX)                                         // MOVQ CX, AX
  1515          self.mapassign_fastx(vt, _F_mapassign_fast32)                       // MAPASSIGN int32, mapassign_fast32
  1516      }
  1517  }
  1518  
  1519  func (self *_Assembler) _asm_OP_map_key_i64(p *_Instr) {
  1520      self.parse_signed(int64Type, "", p.vi())                                 // PARSE     int64
  1521      self.match_char('"')
  1522      if vt := p.vt(); !mapfast(vt) {
  1523          self.mapassign_std(vt, _VAR_st_Iv)              // MAPASSIGN int64, mapassign, st.Iv
  1524      } else {
  1525          self.Emit("MOVQ", _VAR_st_Iv, _AX)              // MOVQ      st.Iv, AX
  1526          self.mapassign_fastx(vt, _F_mapassign_fast64)   // MAPASSIGN int64, mapassign_fast64
  1527      }
  1528  }
  1529  
  1530  func (self *_Assembler) _asm_OP_map_key_u8(p *_Instr) {
  1531      self.parse_unsigned(uint8Type, "", p.vi())                                   // PARSE     uint8
  1532      self.range_unsigned_CX(_I_uint8, _T_uint8, math.MaxUint8)  // RANGE     uint8
  1533      self.match_char('"')
  1534      self.mapassign_std(p.vt(), _VAR_st_Iv)                    // MAPASSIGN uint8, vt.Iv
  1535  }
  1536  
  1537  func (self *_Assembler) _asm_OP_map_key_u16(p *_Instr) {
  1538      self.parse_unsigned(uint16Type, "", p.vi())                                       // PARSE     uint16
  1539      self.range_unsigned_CX(_I_uint16, _T_uint16, math.MaxUint16)   // RANGE     uint16
  1540      self.match_char('"')
  1541      self.mapassign_std(p.vt(), _VAR_st_Iv)                      // MAPASSIGN uint16, vt.Iv
  1542  }
  1543  
  1544  func (self *_Assembler) _asm_OP_map_key_u32(p *_Instr) {
  1545      self.parse_unsigned(uint32Type, "", p.vi())                                       // PARSE     uint32
  1546      self.range_unsigned_CX(_I_uint32, _T_uint32, math.MaxUint32)   // RANGE     uint32
  1547      self.match_char('"')
  1548      if vt := p.vt(); !mapfast(vt) {
  1549          self.mapassign_std(vt, _VAR_st_Iv)                      // MAPASSIGN uint32, vt.Iv
  1550      } else {
  1551          self.Emit("MOVQ", _CX, _AX)                             // MOVQ CX, AX
  1552          self.mapassign_fastx(vt, _F_mapassign_fast32)           // MAPASSIGN uint32, mapassign_fast32
  1553      }
  1554  }
  1555  
  1556  func (self *_Assembler) _asm_OP_map_key_u64(p *_Instr) {
  1557      self.parse_unsigned(uint64Type, "", p.vi())                                       // PARSE     uint64
  1558      self.match_char('"')
  1559      if vt := p.vt(); !mapfast(vt) {
  1560          self.mapassign_std(vt, _VAR_st_Iv)                      // MAPASSIGN uint64, vt.Iv
  1561      } else {
  1562          self.Emit("MOVQ", _VAR_st_Iv, _AX)                      // MOVQ      st.Iv, AX
  1563          self.mapassign_fastx(vt, _F_mapassign_fast64)           // MAPASSIGN uint64, mapassign_fast64
  1564      }
  1565  }
  1566  
  1567  func (self *_Assembler) _asm_OP_map_key_f32(p *_Instr) {
  1568      self.parse_number(float32Type, "", p.vi())                     // PARSE     NUMBER
  1569      self.range_single_X0()                     // RANGE     float32
  1570      self.Emit("MOVSS", _X0, _VAR_st_Dv)     // MOVSS     X0, st.Dv
  1571      self.match_char('"')
  1572      self.mapassign_std(p.vt(), _VAR_st_Dv)  // MAPASSIGN ${p.vt()}, mapassign, st.Dv
  1573  }
  1574  
  1575  func (self *_Assembler) _asm_OP_map_key_f64(p *_Instr) {
  1576      self.parse_number(float64Type, "", p.vi())                     // PARSE     NUMBER
  1577      self.match_char('"')
  1578      self.mapassign_std(p.vt(), _VAR_st_Dv)  // MAPASSIGN ${p.vt()}, mapassign, st.Dv
  1579  }
  1580  
  1581  func (self *_Assembler) _asm_OP_map_key_str(p *_Instr) {
  1582      self.parse_string()                          // PARSE     STRING
  1583      self.unquote_once(_ARG_sv_p, _ARG_sv_n, true, true)      // UNQUOTE   once, sv.p, sv.n
  1584      if vt := p.vt(); !mapfast(vt) {
  1585          self.valloc(vt.Key(), _DI)
  1586          self.Emit("MOVOU", _ARG_sv, _X0)
  1587          self.Emit("MOVOU", _X0, jit.Ptr(_DI, 0))
  1588          self.mapassign_std(vt, jit.Ptr(_DI, 0))        // MAPASSIGN string, DI, SI
  1589      } else {
  1590          self.mapassign_str_fast(vt, _ARG_sv_p, _ARG_sv_n)    // MAPASSIGN string, DI, SI
  1591      }
  1592  }
  1593  
  1594  func (self *_Assembler) _asm_OP_map_key_utext(p *_Instr) {
  1595      self.parse_string()                         // PARSE     STRING
  1596      self.unquote_once(_ARG_sv_p, _ARG_sv_n, true, true)     // UNQUOTE   once, sv.p, sv.n
  1597      self.mapassign_utext(p.vt(), false)         // MAPASSIGN utext, ${p.vt()}, false
  1598  }
  1599  
  1600  func (self *_Assembler) _asm_OP_map_key_utext_p(p *_Instr) {
  1601      self.parse_string()                         // PARSE     STRING
  1602      self.unquote_once(_ARG_sv_p, _ARG_sv_n, true, true)     // UNQUOTE   once, sv.p, sv.n
  1603      self.mapassign_utext(p.vt(), true)          // MAPASSIGN utext, ${p.vt()}, true
  1604  }
  1605  
  1606  func (self *_Assembler) _asm_OP_array_skip(_ *_Instr) {
  1607      self.call_sf(_F_skip_array)                 // CALL_SF skip_array
  1608      self.Emit("TESTQ", _AX, _AX)                // TESTQ   AX, AX
  1609      self.Sjmp("JS"   , _LB_parsing_error_v)     // JS      _parse_error_v
  1610  }
  1611  
  1612  func (self *_Assembler) _asm_OP_array_clear(p *_Instr) {
  1613      self.mem_clear_rem(p.i64(), true)
  1614  }
  1615  
  1616  func (self *_Assembler) _asm_OP_array_clear_p(p *_Instr) {
  1617      self.mem_clear_rem(p.i64(), false)
  1618  }
  1619  
  1620  func (self *_Assembler) _asm_OP_slice_init(p *_Instr) {
  1621      self.Emit("XORL" , _AX, _AX)                    // XORL    AX, AX
  1622      self.Emit("MOVQ" , _AX, jit.Ptr(_VP, 8))        // MOVQ    AX, 8(VP)
  1623      self.Emit("MOVQ" , jit.Ptr(_VP, 16), _BX)       // MOVQ    16(VP), BX
  1624      self.Emit("TESTQ", _BX, _BX)                    // TESTQ   BX, BX
  1625      self.Sjmp("JNZ"  , "_done_{n}")                 // JNZ     _done_{n}
  1626      self.Emit("MOVQ" , jit.Imm(_MinSlice), _CX)     // MOVQ    ${_MinSlice}, CX
  1627      self.Emit("MOVQ" , _CX, jit.Ptr(_VP, 16))       // MOVQ    CX, 16(VP)
  1628      self.Emit("MOVQ" , jit.Type(p.vt()), _AX)       // MOVQ    ${p.vt()}, DX
  1629      self.call_go(_F_makeslice)                      // CALL_GO makeslice
  1630      self.WritePtrAX(7, jit.Ptr(_VP, 0), false)      // MOVQ    AX, (VP)
  1631      self.Emit("XORL" , _AX, _AX)                    // XORL    AX, AX
  1632      self.Emit("MOVQ" , _AX, jit.Ptr(_VP, 8))        // MOVQ    AX, 8(VP)
  1633      self.Link("_done_{n}")                          // _done_{n}
  1634  }
  1635  
  1636  func (self *_Assembler) _asm_OP_check_empty(p *_Instr) {
  1637      rbracket := p.vb()
  1638      if rbracket == ']' {
  1639          self.check_eof(1)
  1640          self.Emit("LEAQ", jit.Ptr(_IC, 1), _AX)                              // LEAQ    1(IC), AX
  1641          self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm(int64(rbracket))) // CMPB    (IP)(IC), ']'
  1642          self.Sjmp("JNE" , "_not_empty_array_{n}")                            // JNE     _not_empty_array_{n}
  1643          self.Emit("MOVQ", _AX, _IC)                                          // MOVQ    AX, IC
  1644          self.Emit("MOVQ", jit.Imm(_Zero_Base), _AX)
  1645          self.WritePtrAX(9, jit.Ptr(_VP, 0), false)
  1646          self.Emit("PXOR", _X0, _X0)                                          // PXOR    X0, X0
  1647          self.Emit("MOVOU", _X0, jit.Ptr(_VP, 8))                             // MOVOU   X0, 8(VP)
  1648          self.Xjmp("JMP" , p.vi())                                            // JMP     {p.vi()}
  1649          self.Link("_not_empty_array_{n}")
  1650      } else {
  1651          panic("only implement check empty array here!")
  1652      }
  1653  }
  1654  
  1655  func (self *_Assembler) _asm_OP_slice_append(p *_Instr) {
  1656      self.Emit("MOVQ" , jit.Ptr(_VP, 8), _AX)            // MOVQ    8(VP), AX
  1657      self.Emit("CMPQ" , _AX, jit.Ptr(_VP, 16))           // CMPQ    AX, 16(VP)
  1658      self.Sjmp("JB"   , "_index_{n}")                    // JB      _index_{n}
  1659      self.Emit("MOVQ" , _AX, _SI)                        // MOVQ    AX, SI
  1660      self.Emit("SHLQ" , jit.Imm(1), _SI)                 // SHLQ    $1, SI
  1661      self.Emit("MOVQ" , jit.Type(p.vt()), _AX)           // MOVQ    ${p.vt()}, AX
  1662      self.Emit("MOVQ" , jit.Ptr(_VP, 0), _BX)            // MOVQ   (VP), BX
  1663      self.Emit("MOVQ" , jit.Ptr(_VP, 8), _CX)            // MOVQ    8(VP), CX
  1664      self.Emit("MOVQ" , jit.Ptr(_VP, 16), _DI)           // MOVQ    16(VP), DI
  1665      self.call_go(_F_growslice)                          // CALL_GO growslice
  1666      self.WritePtrAX(8, jit.Ptr(_VP, 0), false)          // MOVQ    AX, (VP)
  1667      self.Emit("MOVQ" , _BX, jit.Ptr(_VP, 8))            // MOVQ    BX, 8(VP)
  1668      self.Emit("MOVQ" , _CX, jit.Ptr(_VP, 16))           // MOVQ    CX, 16(VP)
  1669  
  1670      // because growslice not zero memory {oldcap, newlen} when append et not has ptrdata.
  1671      // but we should zero it, avoid decode it as random values.
  1672      if rt.UnpackType(p.vt()).PtrData == 0 {
  1673          self.Emit("MOVQ" , _CX, _DI)                        // MOVQ    CX, DI
  1674          self.Emit("SUBQ" , _BX, _DI)                        // MOVQ    BX, DI
  1675      
  1676          self.Emit("ADDQ" , jit.Imm(1), jit.Ptr(_VP, 8))     // ADDQ    $1, 8(VP)
  1677          self.Emit("MOVQ" , _AX, _VP)                        // MOVQ    AX, VP
  1678          self.Emit("MOVQ" , jit.Imm(int64(p.vlen())), _CX)   // MOVQ    ${p.vlen()}, CX
  1679          self.Emit("MOVQ" , _BX, _AX)                        // MOVQ    BX, AX 
  1680          self.From("MULQ" , _CX)                             // MULQ    CX
  1681          self.Emit("ADDQ" , _AX, _VP)                        // ADDQ    AX, VP
  1682  
  1683          self.Emit("MOVQ" , _DI, _AX)                        // MOVQ    SI, AX
  1684          self.From("MULQ" , _CX)                             // MULQ    BX
  1685          self.Emit("MOVQ" , _AX, _BX)                        // ADDQ    AX, BX
  1686          self.Emit("MOVQ" , _VP, _AX)                        // MOVQ    VP, AX
  1687          self.mem_clear_fn(true)                             // CALL_GO memclr{Has,NoHeap}
  1688          self.Sjmp("JMP", "_append_slice_end_{n}")
  1689      }
  1690  
  1691      self.Emit("MOVQ" , _BX, _AX)                        // MOVQ    BX, AX
  1692      self.Link("_index_{n}")                             // _index_{n}:
  1693      self.Emit("ADDQ" , jit.Imm(1), jit.Ptr(_VP, 8))     // ADDQ    $1, 8(VP)
  1694      self.Emit("MOVQ" , jit.Ptr(_VP, 0), _VP)            // MOVQ    (VP), VP
  1695      self.Emit("MOVQ" , jit.Imm(int64(p.vlen())), _CX)   // MOVQ    ${p.vlen()}, CX
  1696      self.From("MULQ" , _CX)                             // MULQ    CX
  1697      self.Emit("ADDQ" , _AX, _VP)                        // ADDQ    AX, VP
  1698      self.Link("_append_slice_end_{n}")
  1699  }
  1700  
  1701  func (self *_Assembler) _asm_OP_object_skip(_ *_Instr) {
  1702      self.call_sf(_F_skip_object)                // CALL_SF skip_object
  1703      self.Emit("TESTQ", _AX, _AX)                // TESTQ   AX, AX
  1704      self.Sjmp("JS"   , _LB_parsing_error_v)     // JS      _parse_error_v
  1705  }
  1706  
  1707  func (self *_Assembler) _asm_OP_object_next(_ *_Instr) {
  1708      self.call_sf(_F_skip_one)                   // CALL_SF skip_one
  1709      self.Emit("TESTQ", _AX, _AX)                // TESTQ   AX, AX
  1710      self.Sjmp("JS"   , _LB_parsing_error_v)     // JS      _parse_error_v
  1711  }
  1712  
  1713  func (self *_Assembler) _asm_OP_struct_field(p *_Instr) {
  1714      assert_eq(caching.FieldEntrySize, 32, "invalid field entry size")
  1715      self.Emit("MOVQ" , jit.Imm(-1), _AX)                        // MOVQ    $-1, AX
  1716      self.Emit("MOVQ" , _AX, _VAR_sr)                            // MOVQ    AX, sr
  1717      self.parse_string()                                         // PARSE   STRING
  1718      self.unquote_once(_ARG_sv_p, _ARG_sv_n, true, false)                     // UNQUOTE once, sv.p, sv.n
  1719      self.Emit("LEAQ" , _ARG_sv, _AX)                            // LEAQ    sv, AX
  1720      self.Emit("XORL" , _BX, _BX)                                // XORL    BX, BX
  1721      self.call_go(_F_strhash)                                    // CALL_GO strhash
  1722      self.Emit("MOVQ" , _AX, _R9)                                // MOVQ    AX, R9
  1723      self.Emit("MOVQ" , jit.Imm(freezeFields(p.vf())), _CX)      // MOVQ    ${p.vf()}, CX
  1724      self.Emit("MOVQ" , jit.Ptr(_CX, caching.FieldMap_b), _SI)   // MOVQ    FieldMap.b(CX), SI
  1725      self.Emit("MOVQ" , jit.Ptr(_CX, caching.FieldMap_N), _CX)   // MOVQ    FieldMap.N(CX), CX
  1726      self.Emit("TESTQ", _CX, _CX)                                // TESTQ   CX, CX
  1727      self.Sjmp("JZ"   , "_try_lowercase_{n}")                    // JZ      _try_lowercase_{n}
  1728      self.Link("_loop_{n}")                                      // _loop_{n}:
  1729      self.Emit("XORL" , _DX, _DX)                                // XORL    DX, DX
  1730      self.From("DIVQ" , _CX)                                     // DIVQ    CX
  1731      self.Emit("LEAQ" , jit.Ptr(_DX, 1), _AX)                    // LEAQ    1(DX), AX
  1732      self.Emit("SHLQ" , jit.Imm(5), _DX)                         // SHLQ    $5, DX
  1733      self.Emit("LEAQ" , jit.Sib(_SI, _DX, 1, 0), _DI)            // LEAQ    (SI)(DX), DI
  1734      self.Emit("MOVQ" , jit.Ptr(_DI, _Fe_Hash), _R8)             // MOVQ    FieldEntry.Hash(DI), R8
  1735      self.Emit("TESTQ", _R8, _R8)                                // TESTQ   R8, R8
  1736      self.Sjmp("JZ"   , "_try_lowercase_{n}")                    // JZ      _try_lowercase_{n}
  1737      self.Emit("CMPQ" , _R8, _R9)                                // CMPQ    R8, R9
  1738      self.Sjmp("JNE"  , "_loop_{n}")                             // JNE     _loop_{n}
  1739      self.Emit("MOVQ" , jit.Ptr(_DI, _Fe_Name + 8), _DX)         // MOVQ    FieldEntry.Name+8(DI), DX
  1740      self.Emit("CMPQ" , _DX, _ARG_sv_n)                          // CMPQ    DX, sv.n
  1741      self.Sjmp("JNE"  , "_loop_{n}")                             // JNE     _loop_{n}
  1742      self.Emit("MOVQ" , jit.Ptr(_DI, _Fe_ID), _R8)               // MOVQ    FieldEntry.ID(DI), R8
  1743      self.Emit("MOVQ" , _AX, _VAR_ss_AX)                         // MOVQ    AX, ss.AX
  1744      self.Emit("MOVQ" , _CX, _VAR_ss_CX)                         // MOVQ    CX, ss.CX
  1745      self.Emit("MOVQ" , _SI, _VAR_ss_SI)                         // MOVQ    SI, ss.SI
  1746      self.Emit("MOVQ" , _R8, _VAR_ss_R8)                         // MOVQ    R8, ss.R8
  1747      self.Emit("MOVQ" , _R9, _VAR_ss_R9)                         // MOVQ    R9, ss.R9
  1748      self.Emit("MOVQ" , _ARG_sv_p, _AX)                          // MOVQ    _VAR_sv_p, AX
  1749      self.Emit("MOVQ" , jit.Ptr(_DI, _Fe_Name), _CX)             // MOVQ    FieldEntry.Name(DI), CX
  1750      self.Emit("MOVQ" , _CX, _BX)                                // MOVQ    CX, 8(SP)
  1751      self.Emit("MOVQ" , _DX, _CX)                                // MOVQ    DX, 16(SP)
  1752      self.call_go(_F_memequal)                                   // CALL_GO memequal
  1753      self.Emit("MOVB" , _AX, _DX)                                // MOVB    24(SP), DX
  1754      self.Emit("MOVQ" , _VAR_ss_AX, _AX)                         // MOVQ    ss.AX, AX
  1755      self.Emit("MOVQ" , _VAR_ss_CX, _CX)                         // MOVQ    ss.CX, CX
  1756      self.Emit("MOVQ" , _VAR_ss_SI, _SI)                         // MOVQ    ss.SI, SI
  1757      self.Emit("MOVQ" , _VAR_ss_R9, _R9)                         // MOVQ    ss.R9, R9
  1758      self.Emit("TESTB", _DX, _DX)                                // TESTB   DX, DX
  1759      self.Sjmp("JZ"   , "_loop_{n}")                             // JZ      _loop_{n}
  1760      self.Emit("MOVQ" , _VAR_ss_R8, _R8)                         // MOVQ    ss.R8, R8
  1761      self.Emit("MOVQ" , _R8, _VAR_sr)                            // MOVQ    R8, sr
  1762      self.Sjmp("JMP"  , "_end_{n}")                              // JMP     _end_{n}
  1763      self.Link("_try_lowercase_{n}")                             // _try_lowercase_{n}:
  1764      self.Emit("MOVQ" , jit.Imm(referenceFields(p.vf())), _AX)   // MOVQ    ${p.vf()}, AX
  1765      self.Emit("MOVQ", _ARG_sv_p, _BX)                            // MOVQ   sv, BX
  1766      self.Emit("MOVQ", _ARG_sv_n, _CX)                            // MOVQ   sv, CX
  1767      self.call_go(_F_FieldMap_GetCaseInsensitive)                // CALL_GO FieldMap::GetCaseInsensitive
  1768      self.Emit("MOVQ" , _AX, _VAR_sr)                            // MOVQ    AX, _VAR_sr
  1769      self.Emit("TESTQ", _AX, _AX)                                // TESTQ   AX, AX
  1770      self.Sjmp("JNS"  , "_end_{n}")                              // JNS     _end_{n}
  1771      self.Emit("BTQ"  , jit.Imm(_F_disable_unknown), _ARG_fv)    // BTQ     ${_F_disable_unknown}, fv
  1772      self.Sjmp("JC"   , _LB_field_error)                         // JC      _field_error
  1773      self.Link("_end_{n}")                                       // _end_{n}:
  1774  }
  1775  
  1776  func (self *_Assembler) _asm_OP_unmarshal(p *_Instr) {
  1777      self.unmarshal_json(p.vt(), true)
  1778  }
  1779  
  1780  func (self *_Assembler) _asm_OP_unmarshal_p(p *_Instr) {
  1781      self.unmarshal_json(p.vt(), false)
  1782  }
  1783  
  1784  func (self *_Assembler) _asm_OP_unmarshal_text(p *_Instr) {
  1785      self.unmarshal_text(p.vt(), true)
  1786  }
  1787  
  1788  func (self *_Assembler) _asm_OP_unmarshal_text_p(p *_Instr) {
  1789      self.unmarshal_text(p.vt(), false)
  1790  }
  1791  
  1792  func (self *_Assembler) _asm_OP_lspace(_ *_Instr) {
  1793      self.lspace("_{n}")
  1794  }
  1795  
  1796  func (self *_Assembler) lspace(subfix string) {
  1797      var label = "_lspace" + subfix
  1798      self.Emit("CMPQ"   , _IC, _IL)                      // CMPQ    IC, IL
  1799      self.Sjmp("JAE"    , _LB_eof_error)                 // JAE     _eof_error
  1800      self.Emit("MOVQ"   , jit.Imm(_BM_space), _DX)       // MOVQ    _BM_space, DX
  1801      self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX)  // MOVBQZX (IP)(IC), AX
  1802      self.Emit("CMPQ"   , _AX, jit.Imm(' '))             // CMPQ    AX, $' '
  1803      self.Sjmp("JA"     , label)                // JA      _nospace_{n}
  1804      self.Emit("BTQ"    , _AX, _DX)                      // BTQ     AX, DX
  1805      self.Sjmp("JNC"    , label)                // JNC     _nospace_{n}
  1806  
  1807      /* test up to 4 characters */
  1808      for i := 0; i < 3; i++ {
  1809          self.Emit("ADDQ"   , jit.Imm(1), _IC)               // ADDQ    $1, IC
  1810          self.Emit("CMPQ"   , _IC, _IL)                      // CMPQ    IC, IL
  1811          self.Sjmp("JAE"    , _LB_eof_error)                 // JAE     _eof_error
  1812          self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX)  // MOVBQZX (IP)(IC), AX
  1813          self.Emit("CMPQ"   , _AX, jit.Imm(' '))             // CMPQ    AX, $' '
  1814          self.Sjmp("JA"     , label)                // JA      _nospace_{n}
  1815          self.Emit("BTQ"    , _AX, _DX)                      // BTQ     AX, DX
  1816          self.Sjmp("JNC"    , label)                // JNC     _nospace_{n}
  1817      }
  1818  
  1819      /* handle over to the native function */
  1820      self.Emit("MOVQ"   , _IP, _DI)                      // MOVQ    IP, DI
  1821      self.Emit("MOVQ"   , _IL, _SI)                      // MOVQ    IL, SI
  1822      self.Emit("MOVQ"   , _IC, _DX)                      // MOVQ    IC, DX
  1823      self.callc(_F_lspace)                                // CALL    lspace
  1824      self.Emit("TESTQ"  , _AX, _AX)                      // TESTQ   AX, AX
  1825      self.Sjmp("JS"     , _LB_parsing_error_v)           // JS      _parsing_error_v
  1826      self.Emit("CMPQ"   , _AX, _IL)                      // CMPQ    AX, IL
  1827      self.Sjmp("JAE"    , _LB_eof_error)                 // JAE     _eof_error
  1828      self.Emit("MOVQ"   , _AX, _IC)                      // MOVQ    AX, IC
  1829      self.Link(label)                           // _nospace_{n}:
  1830  }
  1831  
  1832  func (self *_Assembler) _asm_OP_match_char(p *_Instr) {
  1833      self.match_char(p.vb())
  1834  }
  1835  
  1836  func (self *_Assembler) match_char(char byte) {
  1837      self.check_eof(1)
  1838      self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm(int64(char)))  // CMPB (IP)(IC), ${p.vb()}
  1839      self.Sjmp("JNE" , _LB_char_0_error)                                 // JNE  _char_0_error
  1840      self.Emit("ADDQ", jit.Imm(1), _IC)                                  // ADDQ $1, IC
  1841  }
  1842  
  1843  func (self *_Assembler) _asm_OP_check_char(p *_Instr) {
  1844      self.check_eof(1)
  1845      self.Emit("LEAQ"   , jit.Ptr(_IC, 1), _AX)                              // LEAQ    1(IC), AX
  1846      self.Emit("CMPB"   , jit.Sib(_IP, _IC, 1, 0), jit.Imm(int64(p.vb())))   // CMPB    (IP)(IC), ${p.vb()}
  1847      self.Emit("CMOVQEQ", _AX, _IC)                                          // CMOVQEQ AX, IC
  1848      self.Xjmp("JE"     , p.vi())                                            // JE      {p.vi()}
  1849  }
  1850  
  1851  func (self *_Assembler) _asm_OP_check_char_0(p *_Instr) {
  1852      self.check_eof(1)
  1853      self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm(int64(p.vb())))   // CMPB    (IP)(IC), ${p.vb()}
  1854      self.Xjmp("JE"  , p.vi())                                            // JE      {p.vi()}
  1855  }
  1856  
  1857  func (self *_Assembler) _asm_OP_add(p *_Instr) {
  1858      self.Emit("ADDQ", jit.Imm(int64(p.vi())), _IC)  // ADDQ ${p.vi()}, IC
  1859  }
  1860  
  1861  func (self *_Assembler) _asm_OP_load(_ *_Instr) {
  1862      self.Emit("MOVQ", jit.Ptr(_ST, 0), _AX)             // MOVQ (ST), AX
  1863      self.Emit("MOVQ", jit.Sib(_ST, _AX, 1, 0), _VP)     // MOVQ (ST)(AX), VP
  1864  }
  1865  
  1866  func (self *_Assembler) _asm_OP_save(_ *_Instr) {
  1867      self.Emit("MOVQ", jit.Ptr(_ST, 0), _CX)             // MOVQ (ST), CX
  1868      self.Emit("CMPQ", _CX, jit.Imm(_MaxStackBytes))     // CMPQ CX, ${_MaxStackBytes}
  1869      self.Sjmp("JAE"  , _LB_stack_error)                  // JA   _stack_error
  1870      self.WriteRecNotAX(0 , _VP, jit.Sib(_ST, _CX, 1, 8), false, false) // MOVQ VP, 8(ST)(CX)
  1871      self.Emit("ADDQ", jit.Imm(8), _CX)                  // ADDQ $8, CX
  1872      self.Emit("MOVQ", _CX, jit.Ptr(_ST, 0))             // MOVQ CX, (ST)
  1873  }
  1874  
  1875  func (self *_Assembler) _asm_OP_drop(_ *_Instr) {
  1876      self.Emit("MOVQ", jit.Ptr(_ST, 0), _AX)             // MOVQ (ST), AX
  1877      self.Emit("SUBQ", jit.Imm(8), _AX)                  // SUBQ $8, AX
  1878      self.Emit("MOVQ", jit.Sib(_ST, _AX, 1, 8), _VP)     // MOVQ 8(ST)(AX), VP
  1879      self.Emit("MOVQ", _AX, jit.Ptr(_ST, 0))             // MOVQ AX, (ST)
  1880      self.Emit("XORL", _BX, _BX)                         // XORL BX, BX
  1881      self.Emit("MOVQ", _BX, jit.Sib(_ST, _AX, 1, 8))     // MOVQ BX, 8(ST)(AX)
  1882  }
  1883  
  1884  func (self *_Assembler) _asm_OP_drop_2(_ *_Instr) {
  1885      self.Emit("MOVQ" , jit.Ptr(_ST, 0), _AX)            // MOVQ  (ST), AX
  1886      self.Emit("SUBQ" , jit.Imm(16), _AX)                // SUBQ  $16, AX
  1887      self.Emit("MOVQ" , jit.Sib(_ST, _AX, 1, 8), _VP)    // MOVQ  8(ST)(AX), VP
  1888      self.Emit("MOVQ" , _AX, jit.Ptr(_ST, 0))            // MOVQ  AX, (ST)
  1889      self.Emit("PXOR" , _X0, _X0)                        // PXOR  X0, X0
  1890      self.Emit("MOVOU", _X0, jit.Sib(_ST, _AX, 1, 8))    // MOVOU X0, 8(ST)(AX)
  1891  }
  1892  
  1893  func (self *_Assembler) _asm_OP_recurse(p *_Instr) {
  1894      self.Emit("MOVQ", jit.Type(p.vt()), _AX)    // MOVQ   ${p.vt()}, AX
  1895      self.decode_dynamic(_AX, _VP)               // DECODE AX, VP
  1896  }
  1897  
  1898  func (self *_Assembler) _asm_OP_goto(p *_Instr) {
  1899      self.Xjmp("JMP", p.vi())
  1900  }
  1901  
  1902  func (self *_Assembler) _asm_OP_switch(p *_Instr) {
  1903      self.Emit("MOVQ", _VAR_sr, _AX)             // MOVQ sr, AX
  1904      self.Emit("CMPQ", _AX, jit.Imm(p.i64()))    // CMPQ AX, ${len(p.vs())}
  1905      self.Sjmp("JAE" , "_default_{n}")           // JAE  _default_{n}
  1906  
  1907      /* jump table selector */
  1908      self.Byte(0x48, 0x8d, 0x3d)                         // LEAQ    ?(PC), DI
  1909      self.Sref("_switch_table_{n}", 4)                   // ....    &_switch_table_{n}
  1910      self.Emit("MOVLQSX", jit.Sib(_DI, _AX, 4, 0), _AX)  // MOVLQSX (DI)(AX*4), AX
  1911      self.Emit("ADDQ"   , _DI, _AX)                      // ADDQ    DI, AX
  1912      self.Rjmp("JMP"    , _AX)                           // JMP     AX
  1913      self.Link("_switch_table_{n}")                      // _switch_table_{n}:
  1914  
  1915      /* generate the jump table */
  1916      for i, v := range p.vs() {
  1917          self.Xref(v, int64(-i) * 4)
  1918      }
  1919  
  1920      /* default case */
  1921      self.Link("_default_{n}")
  1922      self.NOP()
  1923  }
  1924  
  1925  func (self *_Assembler) print_gc(i int, p1 *_Instr, p2 *_Instr) {
  1926      self.Emit("MOVQ", jit.Imm(int64(p2.op())),  _CX)// MOVQ $(p2.op()), 16(SP)
  1927      self.Emit("MOVQ", jit.Imm(int64(p1.op())),  _BX) // MOVQ $(p1.op()), 8(SP)
  1928      self.Emit("MOVQ", jit.Imm(int64(i)),  _AX)       // MOVQ $(i), (SP)
  1929      self.call_go(_F_println)
  1930  }
  1931  

View as plain text