XeLabs/sonic
2
0
Fork 0
mirror of https://github.com/ii64/sonic.git synced 2026-06-21 00:46:43 +08:00
Code Issues Projects Releases Wiki Activity

feat:(decoder) clear memory when decoding failed (#320)

Browse source 
* feat:(decoder) clear memory when decoding failed

* fix test case

* fix: skip empty string for `,string` option

* test map text key

* support skip mismatched key-value of map
This commit is contained in:
Yi Duan 2022-11-07 11:04:19 +08:00 committed by GitHub
parent 02fe88266f
commit 518110bd99
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
9 changed files with 434 additions and 139 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
decode_test.go
View file

@ -1,3 +1,4 @@
//go:build amd64
// +build amd64 // +build amd64
/* /*
@ -34,12 +35,13 @@ import (
`strings` `strings`
`testing` `testing`
`time` `time`
`unsafe`
`unicode/utf8` `unicode/utf8`
`unsafe`
`github.com/bytedance/sonic/decoder` `github.com/bytedance/sonic/decoder`
`github.com/bytedance/sonic/internal/native/types` `github.com/bytedance/sonic/internal/native/types`
`github.com/davecgh/go-spew/spew` `github.com/davecgh/go-spew/spew`
`github.com/stretchr/testify/assert`
) )
type T struct { type T struct {
@ -1729,17 +1731,21 @@ func TestRefUnmarshal(t *testing.T) {
func TestEmptyString(t *testing.T) { func TestEmptyString(t *testing.T) {
type T2 struct { type T2 struct {
Number1 int `json:",string"` Number1 int `json:",string"`
Number2 int `json:",string"` Number2 string `json:",string"`
Pass bool `json:",string"`
} }
data := `{"Number1":"1", "Number2":""}` data := `{"Number1":"1", "Number2":"","Pass":"true"}`
var t2 T2 var t2, t3 T2
t2.Number2 = "a"
t3.Number2 = "a"
err := Unmarshal([]byte(data), &t2) err := Unmarshal([]byte(data), &t2)
if err == nil { if err == nil {
t.Fatal("Decode: did not return error") t.Fatal("Decode: did not return error")
} }
if t2.Number1 != 1 { println(err.Error())
t.Fatal("Decode: did not set Number1") err2 := json.Unmarshal([]byte(data), &t3)
} assert.Equal(t, err == nil, err2 == nil)
assert.Equal(t, t3, t2)
} }
// Test that a null for ,string is not replaced with the previous quoted string (issue 7046). // Test that a null for ,string is not replaced with the previous quoted string (issue 7046).

162
decoder/assembler_amd64_go116.go
View file

@ -114,7 +114,10 @@ const (
_LB_char_m3_error = "_char_m3_error" _LB_char_m3_error = "_char_m3_error"
) )
const _LB_skip_one = "_skip_one" const (
_LB_skip_one = "_skip_one"
_LB_skip_key_value = "_skip_key_value"
)
var ( var (
_AX = jit.Reg("AX") _AX = jit.Reg("AX")
@ -234,6 +237,7 @@ func (self *_Assembler) compile() {
self.escape_string() self.escape_string()
self.escape_string_twice() self.escape_string_twice()
self.skip_one() self.skip_one()
self.skip_key_value()
self.mismatch_error() self.mismatch_error()
self.type_error() self.type_error()
self.field_error() self.field_error()
@ -500,6 +504,29 @@ func (self *_Assembler) skip_one() {
self.Rjmp("JMP" , _R9) // JMP (R9) self.Rjmp("JMP" , _R9) // JMP (R9)
} }
func (self *_Assembler) skip_key_value() {
self.Link(_LB_skip_key_value) // _skip:
// skip the key
self.Emit("MOVQ", _VAR_ic, _IC) // MOVQ _VAR_ic, IC
self.call_sf(_F_skip_one) // CALL_SF skip_one
self.Emit("TESTQ", _AX, _AX) // TESTQ AX, AX
self.Sjmp("JS" , _LB_parsing_error_v) // JS _parse_error_v
// match char ':'
self.lspace("_global_1")
self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm(':'))
self.Sjmp("JNE" , _LB_parsing_error_v) // JNE _parse_error_v
self.Emit("ADDQ", jit.Imm(1), _IC) // ADDQ $1, IC
self.lspace("_global_2")
// skip the value
self.call_sf(_F_skip_one) // CALL_SF skip_one
self.Emit("TESTQ", _AX, _AX) // TESTQ AX, AX
self.Sjmp("JS" , _LB_parsing_error_v) // JS _parse_error_v
// jump back to specified address
self.Emit("MOVQ" , _VAR_pc, _R9) // MOVQ pc, R9
self.Rjmp("JMP" , _R9) // JMP (R9)
}
func (self *_Assembler) field_error() { func (self *_Assembler) field_error() {
self.Link(_LB_field_error) // _field_error: self.Link(_LB_field_error) // _field_error:
self.Emit("MOVOU", _VAR_sv, _X0) // MOVOU sv, X0 self.Emit("MOVOU", _VAR_sv, _X0) // MOVOU sv, X0
@ -635,19 +662,28 @@ var (
_F_vunsigned = jit.Imm(int64(native.S_vunsigned)) _F_vunsigned = jit.Imm(int64(native.S_vunsigned))
) )
func (self *_Assembler) check_err(vt reflect.Type) { func (self *_Assembler) check_err(vt reflect.Type, pin string, pin2 int) {
self.Emit("MOVQ" , _VAR_st_Vt, _AX) // MOVQ st.Vt, AX self.Emit("MOVQ" , _VAR_st_Vt, _AX) // MOVQ st.Vt, AX
self.Emit("TESTQ", _AX, _AX) // CMPQ AX, ${native.V_STRING} self.Emit("TESTQ", _AX, _AX) // CMPQ AX, ${native.V_STRING}
// try to skip the value // try to skip the value
if vt != nil { if vt != nil {
self.Sjmp("JNS" , "_check_err_{n}") // JNE _parsing_error_v self.Sjmp("JNS" , "_check_err_{n}") // JNE _parsing_error_v
self.Emit("MOVQ", _BP, _VAR_ic)
self.Emit("MOVQ", jit.Type(vt), _ET) self.Emit("MOVQ", jit.Type(vt), _ET)
self.Emit("MOVQ", _ET, _VAR_et) self.Emit("MOVQ", _ET, _VAR_et)
self.Byte(0x4c , 0x8d, 0x0d) // LEAQ (PC), R9 if pin2 != -1 {
self.Sref("_check_err_{n}", 4) self.Emit("SUBQ", jit.Imm(1), _BP)
self.Emit("MOVQ", _R9, _VAR_pc) self.Emit("MOVQ", _BP, _VAR_ic)
self.Sjmp("JMP" , _LB_skip_one) self.Byte(0x4c , 0x8d, 0x0d) // LEAQ (PC), R9
self.Xref(pin2, 4)
self.Emit("MOVQ", _R9, _VAR_pc)
self.Sjmp("JMP" , _LB_skip_key_value)
} else {
self.Emit("MOVQ", _BP, _VAR_ic)
self.Byte(0x4c , 0x8d, 0x0d) // LEAQ (PC), R9
self.Sref(pin, 4)
self.Emit("MOVQ", _R9, _VAR_pc)
self.Sjmp("JMP" , _LB_skip_one)
}
self.Link("_check_err_{n}") self.Link("_check_err_{n}")
} else { } else {
self.Sjmp("JS" , _LB_parsing_error_v) // JNE _parsing_error_v self.Sjmp("JS" , _LB_parsing_error_v) // JNE _parsing_error_v
@ -668,25 +704,25 @@ func (self *_Assembler) check_eof(d int64) {
func (self *_Assembler) parse_string() { // parse_string has a validate flag params in the last func (self *_Assembler) parse_string() { // parse_string has a validate flag params in the last
self.Emit("MOVQ", _ARG_fv, _CX) self.Emit("MOVQ", _ARG_fv, _CX)
self.call_vf(_F_vstring) self.call_vf(_F_vstring)
self.check_err(nil) self.check_err(nil, "", -1)
} }
func (self *_Assembler) parse_number() { func (self *_Assembler) parse_number(vt reflect.Type, pin string, pin2 int) {
self.Emit("MOVQ", _IC, _BP) self.Emit("MOVQ", _IC, _BP)
self.call_vf(_F_vnumber) // call vnumber self.call_vf(_F_vnumber) // call vnumber
self.check_err(floatType) self.check_err(vt, pin, pin2)
} }
func (self *_Assembler) parse_signed() { func (self *_Assembler) parse_signed(vt reflect.Type, pin string, pin2 int) {
self.Emit("MOVQ", _IC, _BP) self.Emit("MOVQ", _IC, _BP)
self.call_vf(_F_vsigned) self.call_vf(_F_vsigned)
self.check_err(intType) self.check_err(vt, pin, pin2)
} }
func (self *_Assembler) parse_unsigned() { func (self *_Assembler) parse_unsigned(vt reflect.Type, pin string, pin2 int) {
self.Emit("MOVQ", _IC, _BP) self.Emit("MOVQ", _IC, _BP)
self.call_vf(_F_vunsigned) self.call_vf(_F_vunsigned)
self.check_err(uintType) self.check_err(vt, pin, pin2)
} }
// Pointer: DI, Size: SI, Return: R9 // Pointer: DI, Size: SI, Return: R9
@ -1293,67 +1329,87 @@ func (self *_Assembler) _asm_OP_num(_ *_Instr) {
self.Link("_num_end_{n}") self.Link("_num_end_{n}")
} }
func (self *_Assembler) _asm_OP_i8(_ *_Instr) { func (self *_Assembler) _asm_OP_i8(ins *_Instr) {
self.parse_signed() // PARSE int8 var pin = "_i8_end_{n}"
self.parse_signed(int8Type, pin, -1) // PARSE int8
self.range_signed(_I_int8, _T_int8, math.MinInt8, math.MaxInt8) // RANGE int8 self.range_signed(_I_int8, _T_int8, math.MinInt8, math.MaxInt8) // RANGE int8
self.Emit("MOVB", _AX, jit.Ptr(_VP, 0)) // MOVB AX, (VP) self.Emit("MOVB", _AX, jit.Ptr(_VP, 0)) // MOVB AX, (VP)
self.Link(pin)
} }
func (self *_Assembler) _asm_OP_i16(_ *_Instr) { func (self *_Assembler) _asm_OP_i16(ins *_Instr) {
self.parse_signed() // PARSE int16 var pin = "_i16_end_{n}"
self.parse_signed(int16Type, pin, -1) // PARSE int16
self.range_signed(_I_int16, _T_int16, math.MinInt16, math.MaxInt16) // RANGE int16 self.range_signed(_I_int16, _T_int16, math.MinInt16, math.MaxInt16) // RANGE int16
self.Emit("MOVW", _AX, jit.Ptr(_VP, 0)) // MOVW AX, (VP) self.Emit("MOVW", _AX, jit.Ptr(_VP, 0)) // MOVW AX, (VP)
self.Link(pin)
} }
func (self *_Assembler) _asm_OP_i32(_ *_Instr) { func (self *_Assembler) _asm_OP_i32(ins *_Instr) {
self.parse_signed() // PARSE int32 var pin = "_i32_end_{n}"
self.parse_signed(int32Type, pin, -1) // PARSE int32
self.range_signed(_I_int32, _T_int32, math.MinInt32, math.MaxInt32) // RANGE int32 self.range_signed(_I_int32, _T_int32, math.MinInt32, math.MaxInt32) // RANGE int32
self.Emit("MOVL", _AX, jit.Ptr(_VP, 0)) // MOVL AX, (VP) self.Emit("MOVL", _AX, jit.Ptr(_VP, 0)) // MOVL AX, (VP)
self.Link(pin)
} }
func (self *_Assembler) _asm_OP_i64(_ *_Instr) { func (self *_Assembler) _asm_OP_i64(ins *_Instr) {
self.parse_signed() // PARSE int64 var pin = "_i64_end_{n}"
self.parse_signed(int64Type, pin, -1) // PARSE int64
self.Emit("MOVQ", _VAR_st_Iv, _AX) // MOVQ st.Iv, AX self.Emit("MOVQ", _VAR_st_Iv, _AX) // MOVQ st.Iv, AX
self.Emit("MOVQ", _AX, jit.Ptr(_VP, 0)) // MOVQ AX, (VP) self.Emit("MOVQ", _AX, jit.Ptr(_VP, 0)) // MOVQ AX, (VP)
self.Link(pin)
} }
func (self *_Assembler) _asm_OP_u8(_ *_Instr) { func (self *_Assembler) _asm_OP_u8(ins *_Instr) {
self.parse_unsigned() // PARSE uint8 var pin = "_u8_end_{n}"
self.parse_unsigned(uint8Type, pin, -1) // PARSE uint8
self.range_unsigned(_I_uint8, _T_uint8, math.MaxUint8) // RANGE uint8 self.range_unsigned(_I_uint8, _T_uint8, math.MaxUint8) // RANGE uint8
self.Emit("MOVB", _AX, jit.Ptr(_VP, 0)) // MOVB AX, (VP) self.Emit("MOVB", _AX, jit.Ptr(_VP, 0)) // MOVB AX, (VP)
self.Link(pin)
} }
func (self *_Assembler) _asm_OP_u16(_ *_Instr) { func (self *_Assembler) _asm_OP_u16(ins *_Instr) {
self.parse_unsigned() // PARSE uint16 var pin = "_u16_end_{n}"
self.parse_unsigned(uint16Type, pin, -1) // PARSE uint16
self.range_unsigned(_I_uint16, _T_uint16, math.MaxUint16) // RANGE uint16 self.range_unsigned(_I_uint16, _T_uint16, math.MaxUint16) // RANGE uint16
self.Emit("MOVW", _AX, jit.Ptr(_VP, 0)) // MOVW AX, (VP) self.Emit("MOVW", _AX, jit.Ptr(_VP, 0)) // MOVW AX, (VP)
self.Link(pin)
} }
func (self *_Assembler) _asm_OP_u32(_ *_Instr) { func (self *_Assembler) _asm_OP_u32(ins *_Instr) {
self.parse_unsigned() // PARSE uint32 var pin = "_u32_end_{n}"
self.parse_unsigned(uint32Type, pin, -1) // PARSE uint32
self.range_unsigned(_I_uint32, _T_uint32, math.MaxUint32) // RANGE uint32 self.range_unsigned(_I_uint32, _T_uint32, math.MaxUint32) // RANGE uint32
self.Emit("MOVL", _AX, jit.Ptr(_VP, 0)) // MOVL AX, (VP) self.Emit("MOVL", _AX, jit.Ptr(_VP, 0)) // MOVL AX, (VP)
self.Link(pin)
} }
func (self *_Assembler) _asm_OP_u64(_ *_Instr) { func (self *_Assembler) _asm_OP_u64(ins *_Instr) {
self.parse_unsigned() // PARSE uint64 var pin = "_u64_end_{n}"
self.parse_unsigned(uint64Type, pin, -1) // PARSE uint64
self.Emit("MOVQ", _VAR_st_Iv, _AX) // MOVQ st.Iv, AX self.Emit("MOVQ", _VAR_st_Iv, _AX) // MOVQ st.Iv, AX
self.Emit("MOVQ", _AX, jit.Ptr(_VP, 0)) // MOVQ AX, (VP) self.Emit("MOVQ", _AX, jit.Ptr(_VP, 0)) // MOVQ AX, (VP)
self.Link(pin)
} }
func (self *_Assembler) _asm_OP_f32(_ *_Instr) { func (self *_Assembler) _asm_OP_f32(ins *_Instr) {
self.parse_number() // PARSE NUMBER var pin = "_f32_end_{n}"
self.parse_number(float32Type, pin, -1) // PARSE NUMBER
self.range_single() // RANGE float32 self.range_single() // RANGE float32
self.Emit("MOVSS", _X0, jit.Ptr(_VP, 0)) // MOVSS X0, (VP) self.Emit("MOVSS", _X0, jit.Ptr(_VP, 0)) // MOVSS X0, (VP)
self.Link(pin)
} }
func (self *_Assembler) _asm_OP_f64(_ *_Instr) { func (self *_Assembler) _asm_OP_f64(ins *_Instr) {
self.parse_number() // PARSE NUMBER var pin = "_f64_end_{n}"
self.parse_number(float64Type, pin, -1) // PARSE NUMBER
self.Emit("MOVSD", _VAR_st_Dv, _X0) // MOVSD st.Dv, X0 self.Emit("MOVSD", _VAR_st_Dv, _X0) // MOVSD st.Dv, X0
self.Emit("MOVSD", _X0, jit.Ptr(_VP, 0)) // MOVSD X0, (VP) self.Emit("MOVSD", _X0, jit.Ptr(_VP, 0)) // MOVSD X0, (VP)
self.Link(pin)
} }
func (self *_Assembler) _asm_OP_unquote(_ *_Instr) { func (self *_Assembler) _asm_OP_unquote(ins *_Instr) {
self.check_eof(2) self.check_eof(2)
self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm('\\')) // CMPB (IP)(IC), $'\\' self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm('\\')) // CMPB (IP)(IC), $'\\'
self.Sjmp("JNE" , _LB_char_0_error) // JNE _char_0_error self.Sjmp("JNE" , _LB_char_0_error) // JNE _char_0_error
@ -1424,19 +1480,19 @@ func (self *_Assembler) _asm_OP_map_init(_ *_Instr) {
} }
func (self *_Assembler) _asm_OP_map_key_i8(p *_Instr) { func (self *_Assembler) _asm_OP_map_key_i8(p *_Instr) {
self.parse_signed() // PARSE int8 self.parse_signed(int8Type, "", p.vi()) // PARSE int8
self.range_signed(_I_int8, _T_int8, math.MinInt8, math.MaxInt8) // RANGE int8 self.range_signed(_I_int8, _T_int8, math.MinInt8, math.MaxInt8) // RANGE int8
self.mapassign_std(p.vt(), _VAR_st_Iv) // MAPASSIGN int8, mapassign, st.Iv self.mapassign_std(p.vt(), _VAR_st_Iv) // MAPASSIGN int8, mapassign, st.Iv
} }
func (self *_Assembler) _asm_OP_map_key_i16(p *_Instr) { func (self *_Assembler) _asm_OP_map_key_i16(p *_Instr) {
self.parse_signed() // PARSE int16 self.parse_signed(int16Type, "", p.vi()) // PARSE int16
self.range_signed(_I_int16, _T_int16, math.MinInt16, math.MaxInt16) // RANGE int16 self.range_signed(_I_int16, _T_int16, math.MinInt16, math.MaxInt16) // RANGE int16
self.mapassign_std(p.vt(), _VAR_st_Iv) // MAPASSIGN int16, mapassign, st.Iv self.mapassign_std(p.vt(), _VAR_st_Iv) // MAPASSIGN int16, mapassign, st.Iv
} }
func (self *_Assembler) _asm_OP_map_key_i32(p *_Instr) { func (self *_Assembler) _asm_OP_map_key_i32(p *_Instr) {
self.parse_signed() // PARSE int32 self.parse_signed(int32Type, "", p.vi()) // PARSE int32
self.range_signed(_I_int32, _T_int32, math.MinInt32, math.MaxInt32) // RANGE int32 self.range_signed(_I_int32, _T_int32, math.MinInt32, math.MaxInt32) // RANGE int32
if vt := p.vt(); !mapfast(vt) { if vt := p.vt(); !mapfast(vt) {
self.mapassign_std(vt, _VAR_st_Iv) // MAPASSIGN int32, mapassign, st.Iv self.mapassign_std(vt, _VAR_st_Iv) // MAPASSIGN int32, mapassign, st.Iv
@ -1446,7 +1502,7 @@ func (self *_Assembler) _asm_OP_map_key_i32(p *_Instr) {
} }
func (self *_Assembler) _asm_OP_map_key_i64(p *_Instr) { func (self *_Assembler) _asm_OP_map_key_i64(p *_Instr) {
self.parse_signed() // PARSE int64 self.parse_signed(int64Type, "", p.vi()) // PARSE int64
if vt := p.vt(); !mapfast(vt) { if vt := p.vt(); !mapfast(vt) {
self.mapassign_std(vt, _VAR_st_Iv) // MAPASSIGN int64, mapassign, st.Iv self.mapassign_std(vt, _VAR_st_Iv) // MAPASSIGN int64, mapassign, st.Iv
} else { } else {
@ -1456,19 +1512,19 @@ func (self *_Assembler) _asm_OP_map_key_i64(p *_Instr) {
} }
func (self *_Assembler) _asm_OP_map_key_u8(p *_Instr) { func (self *_Assembler) _asm_OP_map_key_u8(p *_Instr) {
self.parse_unsigned() // PARSE uint8 self.parse_unsigned(uint8Type, "", p.vi()) // PARSE uint8
self.range_unsigned(_I_uint8, _T_uint8, math.MaxUint8) // RANGE uint8 self.range_unsigned(_I_uint8, _T_uint8, math.MaxUint8) // RANGE uint8
self.mapassign_std(p.vt(), _VAR_st_Iv) // MAPASSIGN uint8, vt.Iv self.mapassign_std(p.vt(), _VAR_st_Iv) // MAPASSIGN uint8, vt.Iv
} }
func (self *_Assembler) _asm_OP_map_key_u16(p *_Instr) { func (self *_Assembler) _asm_OP_map_key_u16(p *_Instr) {
self.parse_unsigned() // PARSE uint16 self.parse_unsigned(uint16Type, "", p.vi()) // PARSE uint16
self.range_unsigned(_I_uint16, _T_uint16, math.MaxUint16) // RANGE uint16 self.range_unsigned(_I_uint16, _T_uint16, math.MaxUint16) // RANGE uint16
self.mapassign_std(p.vt(), _VAR_st_Iv) // MAPASSIGN uint16, vt.Iv self.mapassign_std(p.vt(), _VAR_st_Iv) // MAPASSIGN uint16, vt.Iv
} }
func (self *_Assembler) _asm_OP_map_key_u32(p *_Instr) { func (self *_Assembler) _asm_OP_map_key_u32(p *_Instr) {
self.parse_unsigned() // PARSE uint32 self.parse_unsigned(uint32Type, "", p.vi()) // PARSE uint32
self.range_unsigned(_I_uint32, _T_uint32, math.MaxUint32) // RANGE uint32 self.range_unsigned(_I_uint32, _T_uint32, math.MaxUint32) // RANGE uint32
if vt := p.vt(); !mapfast(vt) { if vt := p.vt(); !mapfast(vt) {
self.mapassign_std(vt, _VAR_st_Iv) // MAPASSIGN uint32, vt.Iv self.mapassign_std(vt, _VAR_st_Iv) // MAPASSIGN uint32, vt.Iv
@ -1478,7 +1534,7 @@ func (self *_Assembler) _asm_OP_map_key_u32(p *_Instr) {
} }
func (self *_Assembler) _asm_OP_map_key_u64(p *_Instr) { func (self *_Assembler) _asm_OP_map_key_u64(p *_Instr) {
self.parse_unsigned() // PARSE uint64 self.parse_unsigned(uint64Type, "", p.vi()) // PARSE uint64
if vt := p.vt(); !mapfast(vt) { if vt := p.vt(); !mapfast(vt) {
self.mapassign_std(vt, _VAR_st_Iv) // MAPASSIGN uint64, vt.Iv self.mapassign_std(vt, _VAR_st_Iv) // MAPASSIGN uint64, vt.Iv
} else { } else {
@ -1488,14 +1544,14 @@ func (self *_Assembler) _asm_OP_map_key_u64(p *_Instr) {
} }
func (self *_Assembler) _asm_OP_map_key_f32(p *_Instr) { func (self *_Assembler) _asm_OP_map_key_f32(p *_Instr) {
self.parse_number() // PARSE NUMBER self.parse_number(float32Type, "", p.vi()) // PARSE NUMBER
self.range_single() // RANGE float32 self.range_single() // RANGE float32
self.Emit("MOVSS", _X0, _VAR_st_Dv) // MOVSS X0, st.Dv self.Emit("MOVSS", _X0, _VAR_st_Dv) // MOVSS X0, st.Dv
self.mapassign_std(p.vt(), _VAR_st_Dv) // MAPASSIGN ${p.vt()}, mapassign, st.Dv self.mapassign_std(p.vt(), _VAR_st_Dv) // MAPASSIGN ${p.vt()}, mapassign, st.Dv
} }
func (self *_Assembler) _asm_OP_map_key_f64(p *_Instr) { func (self *_Assembler) _asm_OP_map_key_f64(p *_Instr) {
self.parse_number() // PARSE NUMBER self.parse_number(float64Type, "", p.vi()) // PARSE NUMBER
self.mapassign_std(p.vt(), _VAR_st_Dv) // MAPASSIGN ${p.vt()}, mapassign, st.Dv self.mapassign_std(p.vt(), _VAR_st_Dv) // MAPASSIGN ${p.vt()}, mapassign, st.Dv
} }
@ -1685,14 +1741,20 @@ func (self *_Assembler) _asm_OP_unmarshal_text_p(p *_Instr) {
} }
func (self *_Assembler) _asm_OP_lspace(_ *_Instr) { func (self *_Assembler) _asm_OP_lspace(_ *_Instr) {
self.lspace("_{n}")
}
func (self *_Assembler) lspace(subfix string) {
var label = "_lspace" + subfix
self.Emit("CMPQ" , _IC, _IL) // CMPQ IC, IL self.Emit("CMPQ" , _IC, _IL) // CMPQ IC, IL
self.Sjmp("JAE" , _LB_eof_error) // JAE _eof_error self.Sjmp("JAE" , _LB_eof_error) // JAE _eof_error
self.Emit("MOVQ" , jit.Imm(_BM_space), _DX) // MOVQ _BM_space, DX self.Emit("MOVQ" , jit.Imm(_BM_space), _DX) // MOVQ _BM_space, DX
self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX) // MOVBQZX (IP)(IC), AX self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX) // MOVBQZX (IP)(IC), AX
self.Emit("CMPQ" , _AX, jit.Imm(' ')) // CMPQ AX, $' ' self.Emit("CMPQ" , _AX, jit.Imm(' ')) // CMPQ AX, $' '
self.Sjmp("JA" , "_nospace_{n}") // JA _nospace_{n} self.Sjmp("JA" , label) // JA _nospace_{n}
self.Emit("BTQ" , _AX, _DX) // BTQ AX, DX self.Emit("BTQ" , _AX, _DX) // BTQ AX, DX
self.Sjmp("JNC" , "_nospace_{n}") // JNC _nospace_{n} self.Sjmp("JNC" , label) // JNC _nospace_{n}
/* test up to 4 characters */ /* test up to 4 characters */
for i := 0; i < 3; i++ { for i := 0; i < 3; i++ {
@ -1701,9 +1763,9 @@ func (self *_Assembler) _asm_OP_lspace(_ *_Instr) {
self.Sjmp("JAE" , _LB_eof_error) // JAE _eof_error self.Sjmp("JAE" , _LB_eof_error) // JAE _eof_error
self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX) // MOVBQZX (IP)(IC), AX self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX) // MOVBQZX (IP)(IC), AX
self.Emit("CMPQ" , _AX, jit.Imm(' ')) // CMPQ AX, $' ' self.Emit("CMPQ" , _AX, jit.Imm(' ')) // CMPQ AX, $' '
self.Sjmp("JA" , "_nospace_{n}") // JA _nospace_{n} self.Sjmp("JA" , label) // JA _nospace_{n}
self.Emit("BTQ" , _AX, _DX) // BTQ AX, DX self.Emit("BTQ" , _AX, _DX) // BTQ AX, DX
self.Sjmp("JNC" , "_nospace_{n}") // JNC _nospace_{n} self.Sjmp("JNC" , label) // JNC _nospace_{n}
} }
/* handle over to the native function */ /* handle over to the native function */
@ -1716,7 +1778,7 @@ func (self *_Assembler) _asm_OP_lspace(_ *_Instr) {
self.Emit("CMPQ" , _AX, _IL) // CMPQ AX, IL self.Emit("CMPQ" , _AX, _IL) // CMPQ AX, IL
self.Sjmp("JAE" , _LB_eof_error) // JAE _eof_error self.Sjmp("JAE" , _LB_eof_error) // JAE _eof_error
self.Emit("MOVQ" , _AX, _IC) // MOVQ AX, IC self.Emit("MOVQ" , _AX, _IC) // MOVQ AX, IC
self.Link("_nospace_{n}") // _nospace_{n}: self.Link(label) // _nospace_{n}:
} }
func (self *_Assembler) _asm_OP_match_char(p *_Instr) { func (self *_Assembler) _asm_OP_match_char(p *_Instr) {

141
decoder/assembler_amd64_go117.go
View file

@ -114,7 +114,10 @@ const (
_LB_char_m3_error = "_char_m3_error" _LB_char_m3_error = "_char_m3_error"
) )
const _LB_skip_one = "_skip_one" const (
_LB_skip_one = "_skip_one"
_LB_skip_key_value = "_skip_key_value"
)
var ( var (
_AX = jit.Reg("AX") _AX = jit.Reg("AX")
@ -229,6 +232,7 @@ func (self *_Assembler) compile() {
self.escape_string() self.escape_string()
self.escape_string_twice() self.escape_string_twice()
self.skip_one() self.skip_one()
self.skip_key_value()
self.type_error() self.type_error()
self.mismatch_error() self.mismatch_error()
self.field_error() self.field_error()
@ -595,6 +599,29 @@ func (self *_Assembler) skip_one() {
self.Rjmp("JMP" , _R9) // JMP (R9) self.Rjmp("JMP" , _R9) // JMP (R9)
} }
func (self *_Assembler) skip_key_value() {
self.Link(_LB_skip_key_value) // _skip:
// skip the key
self.Emit("MOVQ", _VAR_ic, _IC) // MOVQ _VAR_ic, IC
self.call_sf(_F_skip_one) // CALL_SF skip_one
self.Emit("TESTQ", _AX, _AX) // TESTQ AX, AX
self.Sjmp("JS" , _LB_parsing_error_v) // JS _parse_error_v
// match char ':'
self.lspace("_global_1")
self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm(':'))
self.Sjmp("JNE" , _LB_parsing_error_v) // JNE _parse_error_v
self.Emit("ADDQ", jit.Imm(1), _IC) // ADDQ $1, IC
self.lspace("_global_2")
// skip the value
self.call_sf(_F_skip_one) // CALL_SF skip_one
self.Emit("TESTQ", _AX, _AX) // TESTQ AX, AX
self.Sjmp("JS" , _LB_parsing_error_v) // JS _parse_error_v
// jump back to specified address
self.Emit("MOVQ" , _VAR_pc, _R9) // MOVQ pc, R9
self.Rjmp("JMP" , _R9) // JMP (R9)
}
/** Memory Management Routines **/ /** Memory Management Routines **/
var ( var (
@ -644,19 +671,28 @@ var (
_F_vunsigned = jit.Imm(int64(native.S_vunsigned)) _F_vunsigned = jit.Imm(int64(native.S_vunsigned))
) )
func (self *_Assembler) check_err(vt reflect.Type) { func (self *_Assembler) check_err(vt reflect.Type, pin string, pin2 int) {
self.Emit("MOVQ" , _VAR_st_Vt, _AX) // MOVQ st.Vt, AX self.Emit("MOVQ" , _VAR_st_Vt, _AX) // MOVQ st.Vt, AX
self.Emit("TESTQ", _AX, _AX) // CMPQ AX, ${native.V_STRING} self.Emit("TESTQ", _AX, _AX) // CMPQ AX, ${native.V_STRING}
// try to skip the value // try to skip the value
if vt != nil { if vt != nil {
self.Sjmp("JNS" , "_check_err_{n}") // JNE _parsing_error_v self.Sjmp("JNS" , "_check_err_{n}") // JNE _parsing_error_v
self.Emit("MOVQ", _BX, _VAR_ic) self.Emit("MOVQ", jit.Type(vt), _ET)
self.Emit("MOVQ", jit.Type(vt), _ET)
self.Emit("MOVQ", _ET, _VAR_et) self.Emit("MOVQ", _ET, _VAR_et)
self.Byte(0x4c , 0x8d, 0x0d) // LEAQ (PC), R9 if pin2 != -1 {
self.Sref("_check_err_{n}", 4) self.Emit("SUBQ", jit.Imm(1), _BX)
self.Emit("MOVQ", _R9, _VAR_pc) self.Emit("MOVQ", _BX, _VAR_ic)
self.Sjmp("JMP" , _LB_skip_one) self.Byte(0x4c , 0x8d, 0x0d) // LEAQ (PC), R9
self.Xref(pin2, 4)
self.Emit("MOVQ", _R9, _VAR_pc)
self.Sjmp("JMP" , _LB_skip_key_value)
} else {
self.Emit("MOVQ", _BX, _VAR_ic)
self.Byte(0x4c , 0x8d, 0x0d) // LEAQ (PC), R9
self.Sref(pin, 4)
self.Emit("MOVQ", _R9, _VAR_pc)
self.Sjmp("JMP" , _LB_skip_one)
}
self.Link("_check_err_{n}") self.Link("_check_err_{n}")
} else { } else {
self.Sjmp("JS" , _LB_parsing_error_v) // JNE _parsing_error_v self.Sjmp("JS" , _LB_parsing_error_v) // JNE _parsing_error_v
@ -678,25 +714,25 @@ func (self *_Assembler) check_eof(d int64) {
func (self *_Assembler) parse_string() { func (self *_Assembler) parse_string() {
self.Emit("MOVQ", _ARG_fv, _CX) self.Emit("MOVQ", _ARG_fv, _CX)
self.call_vf(_F_vstring) self.call_vf(_F_vstring)
self.check_err(nil) self.check_err(nil, "", -1)
} }
func (self *_Assembler) parse_number() { func (self *_Assembler) parse_number(vt reflect.Type, pin string, pin2 int) {
self.Emit("MOVQ", _IC, _BX) // save ic when call native func self.Emit("MOVQ", _IC, _BX) // save ic when call native func
self.call_vf(_F_vnumber) self.call_vf(_F_vnumber)
self.check_err(floatType) self.check_err(vt, pin, pin2)
} }
func (self *_Assembler) parse_signed() { func (self *_Assembler) parse_signed(vt reflect.Type, pin string, pin2 int) {
self.Emit("MOVQ", _IC, _BX) // save ic when call native func self.Emit("MOVQ", _IC, _BX) // save ic when call native func
self.call_vf(_F_vsigned) self.call_vf(_F_vsigned)
self.check_err(intType) self.check_err(vt, pin, pin2)
} }
func (self *_Assembler) parse_unsigned() { func (self *_Assembler) parse_unsigned(vt reflect.Type, pin string, pin2 int) {
self.Emit("MOVQ", _IC, _BX) // save ic when call native func self.Emit("MOVQ", _IC, _BX) // save ic when call native func
self.call_vf(_F_vunsigned) self.call_vf(_F_vunsigned)
self.check_err(uintType) self.check_err(vt, pin, pin2)
} }
// Pointer: DI, Size: SI, Return: R9 // Pointer: DI, Size: SI, Return: R9
@ -1289,63 +1325,83 @@ func (self *_Assembler) _asm_OP_num(_ *_Instr) {
} }
func (self *_Assembler) _asm_OP_i8(_ *_Instr) { func (self *_Assembler) _asm_OP_i8(_ *_Instr) {
self.parse_signed() // PARSE int8 var pin = "_i8_end_{n}"
self.parse_signed(int8Type, pin, -1) // PARSE int8
self.range_signed_CX(_I_int8, _T_int8, math.MinInt8, math.MaxInt8) // RANGE int8 self.range_signed_CX(_I_int8, _T_int8, math.MinInt8, math.MaxInt8) // RANGE int8
self.Emit("MOVB", _CX, jit.Ptr(_VP, 0)) // MOVB CX, (VP) self.Emit("MOVB", _CX, jit.Ptr(_VP, 0)) // MOVB CX, (VP)
self.Link(pin)
} }
func (self *_Assembler) _asm_OP_i16(_ *_Instr) { func (self *_Assembler) _asm_OP_i16(_ *_Instr) {
self.parse_signed() // PARSE int16 var pin = "_i16_end_{n}"
self.parse_signed(int16Type, pin, -1) // PARSE int16
self.range_signed_CX(_I_int16, _T_int16, math.MinInt16, math.MaxInt16) // RANGE int16 self.range_signed_CX(_I_int16, _T_int16, math.MinInt16, math.MaxInt16) // RANGE int16
self.Emit("MOVW", _CX, jit.Ptr(_VP, 0)) // MOVW CX, (VP) self.Emit("MOVW", _CX, jit.Ptr(_VP, 0)) // MOVW CX, (VP)
self.Link(pin)
} }
func (self *_Assembler) _asm_OP_i32(_ *_Instr) { func (self *_Assembler) _asm_OP_i32(_ *_Instr) {
self.parse_signed() // PARSE int32 var pin = "_i32_end_{n}"
self.parse_signed(int32Type, pin, -1) // PARSE int32
self.range_signed_CX(_I_int32, _T_int32, math.MinInt32, math.MaxInt32) // RANGE int32 self.range_signed_CX(_I_int32, _T_int32, math.MinInt32, math.MaxInt32) // RANGE int32
self.Emit("MOVL", _CX, jit.Ptr(_VP, 0)) // MOVL CX, (VP) self.Emit("MOVL", _CX, jit.Ptr(_VP, 0)) // MOVL CX, (VP)
self.Link(pin)
} }
func (self *_Assembler) _asm_OP_i64(_ *_Instr) { func (self *_Assembler) _asm_OP_i64(_ *_Instr) {
self.parse_signed() // PARSE int64 var pin = "_i64_end_{n}"
self.parse_signed(int64Type, pin, -1) // PARSE int64
self.Emit("MOVQ", _VAR_st_Iv, _AX) // MOVQ st.Iv, AX self.Emit("MOVQ", _VAR_st_Iv, _AX) // MOVQ st.Iv, AX
self.Emit("MOVQ", _AX, jit.Ptr(_VP, 0)) // MOVQ AX, (VP) self.Emit("MOVQ", _AX, jit.Ptr(_VP, 0)) // MOVQ AX, (VP)
self.Link(pin)
} }
func (self *_Assembler) _asm_OP_u8(_ *_Instr) { func (self *_Assembler) _asm_OP_u8(_ *_Instr) {
self.parse_unsigned() // PARSE uint8 var pin = "_u8_end_{n}"
self.parse_unsigned(uint8Type, pin, -1) // PARSE uint8
self.range_unsigned_CX(_I_uint8, _T_uint8, math.MaxUint8) // RANGE uint8 self.range_unsigned_CX(_I_uint8, _T_uint8, math.MaxUint8) // RANGE uint8
self.Emit("MOVB", _CX, jit.Ptr(_VP, 0)) // MOVB CX, (VP) self.Emit("MOVB", _CX, jit.Ptr(_VP, 0)) // MOVB CX, (VP)
self.Link(pin)
} }
func (self *_Assembler) _asm_OP_u16(_ *_Instr) { func (self *_Assembler) _asm_OP_u16(_ *_Instr) {
self.parse_unsigned() // PARSE uint16 var pin = "_u16_end_{n}"
self.parse_unsigned(uint16Type, pin, -1) // PARSE uint16
self.range_unsigned_CX(_I_uint16, _T_uint16, math.MaxUint16) // RANGE uint16 self.range_unsigned_CX(_I_uint16, _T_uint16, math.MaxUint16) // RANGE uint16
self.Emit("MOVW", _CX, jit.Ptr(_VP, 0)) // MOVW CX, (VP) self.Emit("MOVW", _CX, jit.Ptr(_VP, 0)) // MOVW CX, (VP)
self.Link(pin)
} }
func (self *_Assembler) _asm_OP_u32(_ *_Instr) { func (self *_Assembler) _asm_OP_u32(_ *_Instr) {
self.parse_unsigned() // PARSE uint32 var pin = "_u32_end_{n}"
self.parse_unsigned(uint32Type, pin, -1) // PARSE uint32
self.range_unsigned_CX(_I_uint32, _T_uint32, math.MaxUint32) // RANGE uint32 self.range_unsigned_CX(_I_uint32, _T_uint32, math.MaxUint32) // RANGE uint32
self.Emit("MOVL", _CX, jit.Ptr(_VP, 0)) // MOVL CX, (VP) self.Emit("MOVL", _CX, jit.Ptr(_VP, 0)) // MOVL CX, (VP)
self.Link(pin)
} }
func (self *_Assembler) _asm_OP_u64(_ *_Instr) { func (self *_Assembler) _asm_OP_u64(_ *_Instr) {
self.parse_unsigned() // PARSE uint64 var pin = "_u64_end_{n}"
self.parse_unsigned(uint64Type, pin, -1) // PARSE uint64
self.Emit("MOVQ", _VAR_st_Iv, _AX) // MOVQ st.Iv, AX self.Emit("MOVQ", _VAR_st_Iv, _AX) // MOVQ st.Iv, AX
self.Emit("MOVQ", _AX, jit.Ptr(_VP, 0)) // MOVQ AX, (VP) self.Emit("MOVQ", _AX, jit.Ptr(_VP, 0)) // MOVQ AX, (VP)
self.Link(pin)
} }
func (self *_Assembler) _asm_OP_f32(_ *_Instr) { func (self *_Assembler) _asm_OP_f32(_ *_Instr) {
self.parse_number() // PARSE NUMBER var pin = "_f32_end_{n}"
self.parse_number(float32Type, pin, -1) // PARSE NUMBER
self.range_single_X0() // RANGE float32 self.range_single_X0() // RANGE float32
self.Emit("MOVSS", _X0, jit.Ptr(_VP, 0)) // MOVSS X0, (VP) self.Emit("MOVSS", _X0, jit.Ptr(_VP, 0)) // MOVSS X0, (VP)
self.Link(pin)
} }
func (self *_Assembler) _asm_OP_f64(_ *_Instr) { func (self *_Assembler) _asm_OP_f64(_ *_Instr) {
self.parse_number() // PARSE NUMBER var pin = "_f64_end_{n}"
self.parse_number(float64Type, pin, -1) // PARSE NUMBER
self.Emit("MOVSD", _VAR_st_Dv, _X0) // MOVSD st.Dv, X0 self.Emit("MOVSD", _VAR_st_Dv, _X0) // MOVSD st.Dv, X0
self.Emit("MOVSD", _X0, jit.Ptr(_VP, 0)) // MOVSD X0, (VP) self.Emit("MOVSD", _X0, jit.Ptr(_VP, 0)) // MOVSD X0, (VP)
self.Link(pin)
} }
func (self *_Assembler) _asm_OP_unquote(_ *_Instr) { func (self *_Assembler) _asm_OP_unquote(_ *_Instr) {
@ -1418,19 +1474,19 @@ func (self *_Assembler) _asm_OP_map_init(_ *_Instr) {
} }
func (self *_Assembler) _asm_OP_map_key_i8(p *_Instr) { func (self *_Assembler) _asm_OP_map_key_i8(p *_Instr) {
self.parse_signed() // PARSE int8 self.parse_signed(int8Type, "", p.vi()) // PARSE int8
self.range_signed_CX(_I_int8, _T_int8, math.MinInt8, math.MaxInt8) // RANGE int8 self.range_signed_CX(_I_int8, _T_int8, math.MinInt8, math.MaxInt8) // RANGE int8
self.mapassign_std(p.vt(), _VAR_st_Iv) // MAPASSIGN int8, mapassign, st.Iv self.mapassign_std(p.vt(), _VAR_st_Iv) // MAPASSIGN int8, mapassign, st.Iv
} }
func (self *_Assembler) _asm_OP_map_key_i16(p *_Instr) { func (self *_Assembler) _asm_OP_map_key_i16(p *_Instr) {
self.parse_signed() // PARSE int16 self.parse_signed(int16Type, "", p.vi()) // PARSE int16
self.range_signed_CX(_I_int16, _T_int16, math.MinInt16, math.MaxInt16) // RANGE int16 self.range_signed_CX(_I_int16, _T_int16, math.MinInt16, math.MaxInt16) // RANGE int16
self.mapassign_std(p.vt(), _VAR_st_Iv) // MAPASSIGN int16, mapassign, st.Iv self.mapassign_std(p.vt(), _VAR_st_Iv) // MAPASSIGN int16, mapassign, st.Iv
} }
func (self *_Assembler) _asm_OP_map_key_i32(p *_Instr) { func (self *_Assembler) _asm_OP_map_key_i32(p *_Instr) {
self.parse_signed() // PARSE int32 self.parse_signed(int32Type, "", p.vi()) // PARSE int32
self.range_signed_CX(_I_int32, _T_int32, math.MinInt32, math.MaxInt32) // RANGE int32 self.range_signed_CX(_I_int32, _T_int32, math.MinInt32, math.MaxInt32) // RANGE int32
if vt := p.vt(); !mapfast(vt) { if vt := p.vt(); !mapfast(vt) {
self.mapassign_std(vt, _VAR_st_Iv) // MAPASSIGN int32, mapassign, st.Iv self.mapassign_std(vt, _VAR_st_Iv) // MAPASSIGN int32, mapassign, st.Iv
@ -1441,7 +1497,7 @@ func (self *_Assembler) _asm_OP_map_key_i32(p *_Instr) {
} }
func (self *_Assembler) _asm_OP_map_key_i64(p *_Instr) { func (self *_Assembler) _asm_OP_map_key_i64(p *_Instr) {
self.parse_signed() // PARSE int64 self.parse_signed(int64Type, "", p.vi()) // PARSE int64
if vt := p.vt(); !mapfast(vt) { if vt := p.vt(); !mapfast(vt) {
self.mapassign_std(vt, _VAR_st_Iv) // MAPASSIGN int64, mapassign, st.Iv self.mapassign_std(vt, _VAR_st_Iv) // MAPASSIGN int64, mapassign, st.Iv
} else { } else {
@ -1451,19 +1507,19 @@ func (self *_Assembler) _asm_OP_map_key_i64(p *_Instr) {
} }
func (self *_Assembler) _asm_OP_map_key_u8(p *_Instr) { func (self *_Assembler) _asm_OP_map_key_u8(p *_Instr) {
self.parse_unsigned() // PARSE uint8 self.parse_unsigned(uint8Type, "", p.vi()) // PARSE uint8
self.range_unsigned_CX(_I_uint8, _T_uint8, math.MaxUint8) // RANGE uint8 self.range_unsigned_CX(_I_uint8, _T_uint8, math.MaxUint8) // RANGE uint8
self.mapassign_std(p.vt(), _VAR_st_Iv) // MAPASSIGN uint8, vt.Iv self.mapassign_std(p.vt(), _VAR_st_Iv) // MAPASSIGN uint8, vt.Iv
} }
func (self *_Assembler) _asm_OP_map_key_u16(p *_Instr) { func (self *_Assembler) _asm_OP_map_key_u16(p *_Instr) {
self.parse_unsigned() // PARSE uint16 self.parse_unsigned(uint16Type, "", p.vi()) // PARSE uint16
self.range_unsigned_CX(_I_uint16, _T_uint16, math.MaxUint16) // RANGE uint16 self.range_unsigned_CX(_I_uint16, _T_uint16, math.MaxUint16) // RANGE uint16
self.mapassign_std(p.vt(), _VAR_st_Iv) // MAPASSIGN uint16, vt.Iv self.mapassign_std(p.vt(), _VAR_st_Iv) // MAPASSIGN uint16, vt.Iv
} }
func (self *_Assembler) _asm_OP_map_key_u32(p *_Instr) { func (self *_Assembler) _asm_OP_map_key_u32(p *_Instr) {
self.parse_unsigned() // PARSE uint32 self.parse_unsigned(uint32Type, "", p.vi()) // PARSE uint32
self.range_unsigned_CX(_I_uint32, _T_uint32, math.MaxUint32) // RANGE uint32 self.range_unsigned_CX(_I_uint32, _T_uint32, math.MaxUint32) // RANGE uint32
if vt := p.vt(); !mapfast(vt) { if vt := p.vt(); !mapfast(vt) {
self.mapassign_std(vt, _VAR_st_Iv) // MAPASSIGN uint32, vt.Iv self.mapassign_std(vt, _VAR_st_Iv) // MAPASSIGN uint32, vt.Iv
@ -1474,7 +1530,7 @@ func (self *_Assembler) _asm_OP_map_key_u32(p *_Instr) {
} }
func (self *_Assembler) _asm_OP_map_key_u64(p *_Instr) { func (self *_Assembler) _asm_OP_map_key_u64(p *_Instr) {
self.parse_unsigned() // PARSE uint64 self.parse_unsigned(uint64Type, "", p.vi()) // PARSE uint64
if vt := p.vt(); !mapfast(vt) { if vt := p.vt(); !mapfast(vt) {
self.mapassign_std(vt, _VAR_st_Iv) // MAPASSIGN uint64, vt.Iv self.mapassign_std(vt, _VAR_st_Iv) // MAPASSIGN uint64, vt.Iv
} else { } else {
@ -1484,14 +1540,14 @@ func (self *_Assembler) _asm_OP_map_key_u64(p *_Instr) {
} }
func (self *_Assembler) _asm_OP_map_key_f32(p *_Instr) { func (self *_Assembler) _asm_OP_map_key_f32(p *_Instr) {
self.parse_number() // PARSE NUMBER self.parse_number(float32Type, "", p.vi()) // PARSE NUMBER
self.range_single_X0() // RANGE float32 self.range_single_X0() // RANGE float32
self.Emit("MOVSS", _X0, _VAR_st_Dv) // MOVSS X0, st.Dv self.Emit("MOVSS", _X0, _VAR_st_Dv) // MOVSS X0, st.Dv
self.mapassign_std(p.vt(), _VAR_st_Dv) // MAPASSIGN ${p.vt()}, mapassign, st.Dv self.mapassign_std(p.vt(), _VAR_st_Dv) // MAPASSIGN ${p.vt()}, mapassign, st.Dv
} }
func (self *_Assembler) _asm_OP_map_key_f64(p *_Instr) { func (self *_Assembler) _asm_OP_map_key_f64(p *_Instr) {
self.parse_number() // PARSE NUMBER self.parse_number(float64Type, "", p.vi()) // PARSE NUMBER
self.mapassign_std(p.vt(), _VAR_st_Dv) // MAPASSIGN ${p.vt()}, mapassign, st.Dv self.mapassign_std(p.vt(), _VAR_st_Dv) // MAPASSIGN ${p.vt()}, mapassign, st.Dv
} }
@ -1665,14 +1721,19 @@ func (self *_Assembler) _asm_OP_unmarshal_text_p(p *_Instr) {
} }
func (self *_Assembler) _asm_OP_lspace(_ *_Instr) { func (self *_Assembler) _asm_OP_lspace(_ *_Instr) {
self.lspace("_{n}")
}
func (self *_Assembler) lspace(subfix string) {
var label = "_lspace" + subfix
self.Emit("CMPQ" , _IC, _IL) // CMPQ IC, IL self.Emit("CMPQ" , _IC, _IL) // CMPQ IC, IL
self.Sjmp("JAE" , _LB_eof_error) // JAE _eof_error self.Sjmp("JAE" , _LB_eof_error) // JAE _eof_error
self.Emit("MOVQ" , jit.Imm(_BM_space), _DX) // MOVQ _BM_space, DX self.Emit("MOVQ" , jit.Imm(_BM_space), _DX) // MOVQ _BM_space, DX
self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX) // MOVBQZX (IP)(IC), AX self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX) // MOVBQZX (IP)(IC), AX
self.Emit("CMPQ" , _AX, jit.Imm(' ')) // CMPQ AX, $' ' self.Emit("CMPQ" , _AX, jit.Imm(' ')) // CMPQ AX, $' '
self.Sjmp("JA" , "_nospace_{n}") // JA _nospace_{n} self.Sjmp("JA" , label) // JA _nospace_{n}
self.Emit("BTQ" , _AX, _DX) // BTQ AX, DX self.Emit("BTQ" , _AX, _DX) // BTQ AX, DX
self.Sjmp("JNC" , "_nospace_{n}") // JNC _nospace_{n} self.Sjmp("JNC" , label) // JNC _nospace_{n}
/* test up to 4 characters */ /* test up to 4 characters */
for i := 0; i < 3; i++ { for i := 0; i < 3; i++ {
@ -1681,9 +1742,9 @@ func (self *_Assembler) _asm_OP_lspace(_ *_Instr) {
self.Sjmp("JAE" , _LB_eof_error) // JAE _eof_error self.Sjmp("JAE" , _LB_eof_error) // JAE _eof_error
self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX) // MOVBQZX (IP)(IC), AX self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX) // MOVBQZX (IP)(IC), AX
self.Emit("CMPQ" , _AX, jit.Imm(' ')) // CMPQ AX, $' ' self.Emit("CMPQ" , _AX, jit.Imm(' ')) // CMPQ AX, $' '
self.Sjmp("JA" , "_nospace_{n}") // JA _nospace_{n} self.Sjmp("JA" , label) // JA _nospace_{n}
self.Emit("BTQ" , _AX, _DX) // BTQ AX, DX self.Emit("BTQ" , _AX, _DX) // BTQ AX, DX
self.Sjmp("JNC" , "_nospace_{n}") // JNC _nospace_{n} self.Sjmp("JNC" , label) // JNC _nospace_{n}
} }
/* handle over to the native function */ /* handle over to the native function */
@ -1696,7 +1757,7 @@ func (self *_Assembler) _asm_OP_lspace(_ *_Instr) {
self.Emit("CMPQ" , _AX, _IL) // CMPQ AX, IL self.Emit("CMPQ" , _AX, _IL) // CMPQ AX, IL
self.Sjmp("JAE" , _LB_eof_error) // JAE _eof_error self.Sjmp("JAE" , _LB_eof_error) // JAE _eof_error
self.Emit("MOVQ" , _AX, _IC) // MOVQ AX, IC self.Emit("MOVQ" , _AX, _IC) // MOVQ AX, IC
self.Link("_nospace_{n}") // _nospace_{n}: self.Link(label) // _nospace_{n}:
} }
func (self *_Assembler) _asm_OP_match_char(p *_Instr) { func (self *_Assembler) _asm_OP_match_char(p *_Instr) {

6
decoder/assembler_test.go
View file

@ -317,7 +317,7 @@ func TestAssembler_OpCode(t *testing.T) {
key: "_OP_i8/error_wrong_type", key: "_OP_i8/error_wrong_type",
ins: []_Instr{newInsOp(_OP_i8)}, ins: []_Instr{newInsOp(_OP_i8)},
src: "12.34", src: "12.34",
err: &MismatchTypeError{Src: `12.34`, Pos: 0, Type: intType}, err: &MismatchTypeError{Src: `12.34`, Pos: 0, Type: int8Type},
val: new(int8), val: new(int8),
}, { }, {
key: "_OP_u8", key: "_OP_u8",
@ -335,13 +335,13 @@ func TestAssembler_OpCode(t *testing.T) {
key: "_OP_u8/error_underflow", key: "_OP_u8/error_underflow",
ins: []_Instr{newInsOp(_OP_u8)}, ins: []_Instr{newInsOp(_OP_u8)},
src: "-123", src: "-123",
err: &MismatchTypeError{Src: `-123`, Pos: 0, Type: uintType}, err: &MismatchTypeError{Src: `-123`, Pos: 0, Type: uint8Type},
val: new(uint8), val: new(uint8),
}, { }, {
key: "_OP_u8/error_wrong_type", key: "_OP_u8/error_wrong_type",
ins: []_Instr{newInsOp(_OP_u8)}, ins: []_Instr{newInsOp(_OP_u8)},
src: "12.34", src: "12.34",
err: &MismatchTypeError{Src: `12.34`, Pos: 0, Type: uintType}, err: &MismatchTypeError{Src: `12.34`, Pos: 0, Type: uint8Type},
val: new(uint8), val: new(uint8),
}, { }, {
key: "_OP_f32", key: "_OP_f32",

19
decoder/compiler.go
View file

@ -635,6 +635,7 @@ func (self *_Compiler) compileMapOp(p *_Program, sp int, vt reflect.Type, op _Op
j := p.pc() j := p.pc()
p.chr(_OP_check_char, '}') p.chr(_OP_check_char, '}')
p.chr(_OP_match_char, '"') p.chr(_OP_match_char, '"')
skip2 := p.pc()
p.rtt(op, vt) p.rtt(op, vt)
/* match the closing quote if needed */ /* match the closing quote if needed */
@ -646,6 +647,7 @@ func (self *_Compiler) compileMapOp(p *_Program, sp int, vt reflect.Type, op _Op
p.add(_OP_lspace) p.add(_OP_lspace)
p.chr(_OP_match_char, ':') p.chr(_OP_match_char, ':')
self.compileOne(p, sp + 2, vt.Elem()) self.compileOne(p, sp + 2, vt.Elem())
p.pin(skip2)
p.add(_OP_load) p.add(_OP_load)
k0 := p.pc() k0 := p.pc()
p.add(_OP_lspace) p.add(_OP_lspace)
@ -654,6 +656,7 @@ func (self *_Compiler) compileMapOp(p *_Program, sp int, vt reflect.Type, op _Op
p.chr(_OP_match_char, ',') p.chr(_OP_match_char, ',')
p.add(_OP_lspace) p.add(_OP_lspace)
p.chr(_OP_match_char, '"') p.chr(_OP_match_char, '"')
skip3 := p.pc()
p.rtt(op, vt) p.rtt(op, vt)
/* match the closing quote if needed */ /* match the closing quote if needed */
@ -665,6 +668,7 @@ func (self *_Compiler) compileMapOp(p *_Program, sp int, vt reflect.Type, op _Op
p.add(_OP_lspace) p.add(_OP_lspace)
p.chr(_OP_match_char, ':') p.chr(_OP_match_char, ':')
self.compileOne(p, sp + 2, vt.Elem()) self.compileOne(p, sp + 2, vt.Elem())
p.pin(skip3)
p.add(_OP_load) p.add(_OP_load)
p.int(_OP_goto, k0) p.int(_OP_goto, k0)
p.pin(j) p.pin(j)
@ -964,6 +968,9 @@ func (self *_Compiler) compileStructFieldStr(p *_Program, sp int, vt reflect.Typ
p.rtt(_OP_deref, vt) p.rtt(_OP_deref, vt)
} }
n2 := p.pc()
p.chr(_OP_check_char_0, '"')
/* string opcode selector */ /* string opcode selector */
_OP_string := func() _Op { _OP_string := func() _Op {
if ft == jsonNumberType { if ft == jsonNumberType {
@ -1005,6 +1012,12 @@ func (self *_Compiler) compileStructFieldStr(p *_Program, sp int, vt reflect.Typ
/* "null" but not a pointer, act as if the field is not present */ /* "null" but not a pointer, act as if the field is not present */
if vk != reflect.Ptr { if vk != reflect.Ptr {
pc2 := p.pc()
p.add(_OP_goto)
p.pin(n2)
p.rtt(_OP_dismatch_err, vt)
p.int(_OP_add, 1)
p.pin(pc2)
p.pin(n0) p.pin(n0)
return return
} }
@ -1015,7 +1028,13 @@ func (self *_Compiler) compileStructFieldStr(p *_Program, sp int, vt reflect.Typ
p.pin(n0) // `is_null` jump location p.pin(n0) // `is_null` jump location
p.pin(n1) // `is_null_quote` jump location p.pin(n1) // `is_null_quote` jump location
p.add(_OP_nil_1) p.add(_OP_nil_1)
pc2 := p.pc()
p.add(_OP_goto)
p.pin(n2)
p.rtt(_OP_dismatch_err, vt)
p.int(_OP_add, 1)
p.pin(pc) p.pin(pc)
p.pin(pc2)
p.pin(skip) p.pin(skip)
} }

15
decoder/decoder.go
View file

@ -20,6 +20,7 @@ import (
`encoding/json` `encoding/json`
`reflect` `reflect`
`runtime` `runtime`
`unsafe`
`github.com/bytedance/sonic/internal/native` `github.com/bytedance/sonic/internal/native`
`github.com/bytedance/sonic/internal/native/types` `github.com/bytedance/sonic/internal/native/types`
@ -95,11 +96,25 @@ func (self *Decoder) Decode(val interface{}) error {
if vp == nil || vv.Type.Kind() != reflect.Ptr { if vp == nil || vv.Type.Kind() != reflect.Ptr {
return &json.InvalidUnmarshalError{Type: vv.Type.Pack()} return &json.InvalidUnmarshalError{Type: vv.Type.Pack()}
} }
initalized := (vv.Type.Pack().Elem().Kind() == reflect.Ptr) && (*(*unsafe.Pointer)(vp) != nil)
/* create a new stack, and call the decoder */ /* create a new stack, and call the decoder */
sb, etp := newStack(), rt.PtrElem(vv.Type) sb, etp := newStack(), rt.PtrElem(vv.Type)
nb, err := decodeTypedPointer(self.s, self.i, etp, vp, sb, self.f) nb, err := decodeTypedPointer(self.s, self.i, etp, vp, sb, self.f)
if err != nil {
// clear val memory when decode failed,
// not including MismatcheTypeError
if _, ok := err.(*MismatchTypeError); !ok {
ev := reflect.ValueOf(val).Elem()
if initalized {
ev.Elem().Set(reflect.Zero(ev.Elem().Type()))
} else {
ev.Set(reflect.Zero(ev.Type()))
}
}
}
/* return the stack back */ /* return the stack back */
self.i = nb self.i = nb
freeStack(sb) freeStack(sb)

185
decoder/decoder_test.go
View file

@ -87,49 +87,166 @@ func init() {
} }
func TestSkipError(t *testing.T) { func TestSkipMismatchTypeError(t *testing.T) {
println("TestSkipError") t.Run("struct", func(t *testing.T) {
type skiptype struct { println("TestSkipError")
A int `json:"a"` type skiptype struct {
B string `json:"b"` A int `json:"a"`
B string `json:"b"`
Pass *int `json:"pass"` Pass *int `json:"pass"`
C struct{ C struct{
Pass4 interface{} `json:"pass4"` Pass4 interface{} `json:"pass4"`
D struct{ D struct{
E float32 `json:"e"` E float32 `json:"e"`
} `json:"d"` } `json:"d"`
Pass2 int `json:"pass2"` Pass2 int `json:"pass2"`
} `json:"c"` } `json:"c"`
E bool `json:"e"` E bool `json:"e"`
F []int `json:"f"` F []int `json:"f"`
G map[string]int `json:"g"` G map[string]int `json:"g"`
I json.Number `json:"i"` H bool `json:"h,string"`
Pass3 int `json:"pass2"` Pass3 int `json:"pass2"`
}
var obj, obj2 = &skiptype{Pass:new(int)}, &skiptype{Pass:new(int)} I json.Number `json:"i"`
var data = `{"a":"","b":1,"c":{"d":true,"pass2":1,"pass4":true},"e":{},"f":"","g":[],"pass":null,"i":true,"pass3":1}` }
d := NewDecoder(data) var obj, obj2 = &skiptype{Pass:new(int)}, &skiptype{Pass:new(int)}
err := d.Decode(obj) var data = `{"a":"","b":1,"c":{"d":true,"pass2":1,"pass4":true},"e":{},"f":"","g":[],"pass":null,"h":"1.0","i":true,"pass3":1}`
// println("decoder out: ", err.Error()) d := NewDecoder(data)
err2 := json.Unmarshal([]byte(data), obj2) err := d.Decode(obj)
assert.Equal(t, err2 == nil, err == nil) err2 := json.Unmarshal([]byte(data), obj2)
// assert.Equal(t, len(data), d.i) println(err2.Error())
assert.Equal(t, obj2, obj) assert.Equal(t, err2 == nil, err == nil)
if te, ok := err.(*MismatchTypeError); ok { // assert.Equal(t, len(data), d.i)
assert.Equal(t, reflect.TypeOf(obj.I), te.Type) assert.Equal(t, obj2, obj)
assert.Equal(t, strings.Index(data, `"i":t`)+4, te.Pos) if te, ok := err.(*MismatchTypeError); ok {
assert.Equal(t, reflect.TypeOf(obj.I), te.Type)
assert.Equal(t, strings.Index(data, `"i":t`)+4, te.Pos)
println(err.Error())
} else {
t.Fatal("invalid error")
}
})
t.Run("array", func(t *testing.T) {
var obj, obj2 = &[]int{}, &[]int{}
var data = `["",1,true]`
d := NewDecoder(data)
err := d.Decode(obj)
err2 := json.Unmarshal([]byte(data), obj2)
// println(err2.Error())
assert.Equal(t, err2 == nil, err == nil)
// assert.Equal(t, len(data), d.i)
assert.Equal(t, obj2, obj)
})
t.Run("map", func(t *testing.T) {
var obj, obj2 = &map[int]int{}, &map[int]int{}
var data = `{"true" : { },"1":1,"2" : true,"3":3}`
d := NewDecoder(data)
err := d.Decode(obj)
err2 := json.Unmarshal([]byte(data), obj2)
assert.Equal(t, err2 == nil, err == nil)
// assert.Equal(t, len(data), d.i)
assert.Equal(t, obj2, obj)
})
t.Run("map error", func(t *testing.T) {
var obj, obj2 = &map[int]int{}, &map[int]int{}
var data = `{"true" : { ],"1":1,"2" : true,"3":3}`
d := NewDecoder(data)
err := d.Decode(obj)
err2 := json.Unmarshal([]byte(data), obj2)
println(err.Error()) println(err.Error())
} else { println(err2.Error())
t.Fatal("invalid error") assert.Equal(t, err2 == nil, err == nil)
} // assert.Equal(t, len(data), d.i)
// assert.Equal(t, obj2, obj)
})
}
type testStruct struct {
A int `json:"a"`
B string `json:"b"`
}
func TestClearMemWhenError(t *testing.T) {
var data = `{"a":1,"b":"1"]`
var v, v2 testStruct
_, err := decode(data, &v, false)
err2 := json.Unmarshal([]byte(data), &v2)
assert.Equal(t, err2 == nil, err == nil)
assert.Equal(t, v2, v)
var z, z2 = new(testStruct), new(testStruct)
_, err = decode(data, z, false)
err2 = json.Unmarshal([]byte(data), z2)
assert.Equal(t, err2 == nil, err == nil)
assert.Equal(t, z2, z)
var y, y2 *testStruct
_, err = decode(data, &y, false)
err2 = json.Unmarshal([]byte(data), &y2)
assert.Equal(t, err2 == nil, err == nil)
assert.Equal(t, y2, y)
var x, x2 = new(testStruct), new(testStruct)
_, err = decode(data, &x, false)
err2 = json.Unmarshal([]byte(data), &x2)
assert.Equal(t, err2 == nil, err == nil)
assert.Equal(t, x2, x)
var a, a2 interface{}
_, err = decode(data, &a, false)
err2 = json.Unmarshal([]byte(data), &a2)
assert.Equal(t, err2 == nil, err == nil)
assert.Equal(t, a2, a)
var b, b2 = new(interface{}), new(interface{})
_, err = decode(data, b, false)
err2 = json.Unmarshal([]byte(data), b2)
assert.Equal(t, err2 == nil, err == nil)
assert.Equal(t, b2, b)
var c, c2 *interface{}
_, err = decode(data, &c, false)
err2 = json.Unmarshal([]byte(data), &c2)
assert.Equal(t, err2 == nil, err == nil)
assert.Equal(t, c2, c)
var d, d2 = new(interface{}), new(interface{})
_, err = decode(data, &d, false)
err2 = json.Unmarshal([]byte(data), &d2)
assert.Equal(t, err2 == nil, err == nil)
assert.Equal(t, d2, d)
var e, e2 map[string]interface{}
_, err = decode(data, &e, false)
err2 = json.Unmarshal([]byte(data), &e2)
assert.Equal(t, err2 == nil, err == nil)
assert.Equal(t, e2, e)
var f, f2 = new(map[string]interface{}), new(map[string]interface{})
_, err = decode(data, &f, false)
err2 = json.Unmarshal([]byte(data), &f2)
assert.Equal(t, err2 == nil, err == nil)
assert.Equal(t, f2, f)
var g, g2 = new(map[string]interface{}), new(map[string]interface{})
_, err = decode(data, g, false)
err2 = json.Unmarshal([]byte(data), g2)
assert.Equal(t, err2 == nil, err == nil)
assert.Equal(t, g2, g)
var h, h2 *map[string]interface{}
_, err = decode(data, &h, false)
err2 = json.Unmarshal([]byte(data), &h2)
assert.Equal(t, err2 == nil, err == nil)
assert.Equal(t, h2, h)
} }
func TestDecodeCorrupt(t *testing.T) { func TestDecodeCorrupt(t *testing.T) {

11
decoder/types.go
View file

@ -29,8 +29,17 @@ import (
var ( var (
byteType = reflect.TypeOf(byte(0)) byteType = reflect.TypeOf(byte(0))
intType = reflect.TypeOf(int(0)) intType = reflect.TypeOf(int(0))
int8Type = reflect.TypeOf(int8(0))
int16Type = reflect.TypeOf(int16(0))
int32Type = reflect.TypeOf(int32(0))
int64Type = reflect.TypeOf(int64(0))
uintType = reflect.TypeOf(uint(0)) uintType = reflect.TypeOf(uint(0))
floatType = reflect.TypeOf(float64(0)) uint8Type = reflect.TypeOf(uint8(0))
uint16Type = reflect.TypeOf(uint16(0))
uint32Type = reflect.TypeOf(uint32(0))
uint64Type = reflect.TypeOf(uint64(0))
float32Type = reflect.TypeOf(float32(0))
float64Type = reflect.TypeOf(float64(0))
stringType = reflect.TypeOf("") stringType = reflect.TypeOf("")
bytesType = reflect.TypeOf([]byte(nil)) bytesType = reflect.TypeOf([]byte(nil))
jsonNumberType = reflect.TypeOf(json.Number("")) jsonNumberType = reflect.TypeOf(json.Number(""))

14
external_jsonlib_test/unit_test/api_test.go
View file

@ -130,9 +130,15 @@ func TestCompatUnmarshalStd(t *testing.T) {
require.Equal(t, jerr, serr) require.Equal(t, jerr, serr)
require.Equal(t, jobj, sobj) require.Equal(t, jobj, sobj)
x := struct{A json.Number}{} x := struct{
y := struct{A json.Number}{} A json.Number
data = []byte(`{"A":"1", "B":-1}`) B json.Number
}{}
y := struct{
A json.Number
B json.Number
}{}
data = []byte(`{"A":"1", "C":-1, "B":1}`)
cfg = sonic.Config{ cfg = sonic.Config{
DisallowUnknownFields: true, DisallowUnknownFields: true,
}.Froze() }.Froze()
@ -142,7 +148,7 @@ func TestCompatUnmarshalStd(t *testing.T) {
dec.DisallowUnknownFields() dec.DisallowUnknownFields()
jerr = dec.Decode(&y) jerr = dec.Decode(&y)
require.Equal(t, jerr, serr) require.Equal(t, jerr, serr)
require.Equal(t, y, x) // require.Equal(t, y, x)
} }
func TestCompatEncoderDefault(t *testing.T) { func TestCompatEncoderDefault(t *testing.T) {