Lunny Xiao
4 years ago
No known key found for this signature in database
GPG Key ID: C3B7C91B632F738A
111 changed files with 7582 additions and 4823 deletions
-
6go.mod
-
141go.sum
-
41vendor/github.com/goccy/go-json/CHANGELOG.md
-
4vendor/github.com/goccy/go-json/README.md
-
2vendor/github.com/goccy/go-json/docker-compose.yml
-
81vendor/github.com/goccy/go-json/internal/decoder/bytes.go
-
4vendor/github.com/goccy/go-json/internal/decoder/func.go
-
4vendor/github.com/goccy/go-json/internal/decoder/interface.go
-
21vendor/github.com/goccy/go-json/internal/decoder/map.go
-
4vendor/github.com/goccy/go-json/internal/decoder/number.go
-
11vendor/github.com/goccy/go-json/internal/decoder/slice.go
-
24vendor/github.com/goccy/go-json/internal/decoder/string.go
-
16vendor/github.com/goccy/go-json/internal/decoder/struct.go
-
875vendor/github.com/goccy/go-json/internal/encoder/code.go
-
1721vendor/github.com/goccy/go-json/internal/encoder/compiler.go
-
40vendor/github.com/goccy/go-json/internal/encoder/compiler_norace.go
-
37vendor/github.com/goccy/go-json/internal/encoder/compiler_race.go
-
48vendor/github.com/goccy/go-json/internal/encoder/context.go
-
26vendor/github.com/goccy/go-json/internal/encoder/int.go
-
313vendor/github.com/goccy/go-json/internal/encoder/opcode.go
-
780vendor/github.com/goccy/go-json/internal/encoder/optype.go
-
27vendor/github.com/goccy/go-json/internal/encoder/vm/util.go
-
703vendor/github.com/goccy/go-json/internal/encoder/vm/vm.go
-
38vendor/github.com/goccy/go-json/internal/encoder/vm_color/util.go
-
703vendor/github.com/goccy/go-json/internal/encoder/vm_color/vm.go
-
39vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/util.go
-
703vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/vm.go
-
27vendor/github.com/goccy/go-json/internal/encoder/vm_indent/util.go
-
703vendor/github.com/goccy/go-json/internal/encoder/vm_indent/vm.go
-
7vendor/github.com/goccy/go-json/internal/errors/error.go
-
3vendor/github.com/golang/snappy/AUTHORS
-
4vendor/github.com/golang/snappy/CONTRIBUTORS
-
85vendor/github.com/golang/snappy/decode.go
-
494vendor/github.com/golang/snappy/decode_arm64.s
-
1vendor/github.com/golang/snappy/decode_asm.go
-
24vendor/github.com/golang/snappy/decode_other.go
-
4vendor/github.com/golang/snappy/encode.go
-
722vendor/github.com/golang/snappy/encode_arm64.s
-
1vendor/github.com/golang/snappy/encode_asm.go
-
2vendor/github.com/golang/snappy/encode_other.go
-
1vendor/github.com/golang/snappy/go.mod
-
2vendor/github.com/json-iterator/go/README.md
-
2vendor/github.com/json-iterator/go/go.mod
-
5vendor/github.com/json-iterator/go/go.sum
-
2vendor/github.com/modern-go/reflect2/.travis.yml
-
8vendor/github.com/modern-go/reflect2/Gopkg.lock
-
4vendor/github.com/modern-go/reflect2/Gopkg.toml
-
3vendor/github.com/modern-go/reflect2/go.mod
-
23vendor/github.com/modern-go/reflect2/go_above_118.go
-
8vendor/github.com/modern-go/reflect2/go_above_17.go
-
3vendor/github.com/modern-go/reflect2/go_above_19.go
-
21vendor/github.com/modern-go/reflect2/go_below_118.go
-
9vendor/github.com/modern-go/reflect2/go_below_17.go
-
14vendor/github.com/modern-go/reflect2/go_below_19.go
-
20vendor/github.com/modern-go/reflect2/reflect2.go
-
12vendor/github.com/modern-go/reflect2/test.sh
-
51vendor/github.com/modern-go/reflect2/type_map.go
-
26vendor/github.com/modern-go/reflect2/unsafe_link.go
-
8vendor/github.com/modern-go/reflect2/unsafe_map.go
-
12vendor/modules.txt
-
38vendor/xorm.io/xorm/.drone.yml
-
24vendor/xorm.io/xorm/.golangci.yml
-
51vendor/xorm.io/xorm/Makefile
-
44vendor/xorm.io/xorm/README.md
-
44vendor/xorm.io/xorm/README_CN.md
-
2vendor/xorm.io/xorm/caches/encode.go
-
24vendor/xorm.io/xorm/caches/lru.go
-
2vendor/xorm.io/xorm/contexts/hook.go
-
4vendor/xorm.io/xorm/convert/conversion.go
-
2vendor/xorm.io/xorm/core/db.go
-
2vendor/xorm.io/xorm/core/rows.go
-
2vendor/xorm.io/xorm/core/stmt.go
-
1201vendor/xorm.io/xorm/dialects/dameng.go
-
66vendor/xorm.io/xorm/dialects/dialect.go
-
12vendor/xorm.io/xorm/dialects/mssql.go
-
37vendor/xorm.io/xorm/dialects/mysql.go
-
10vendor/xorm.io/xorm/dialects/oracle.go
-
62vendor/xorm.io/xorm/dialects/postgres.go
-
6vendor/xorm.io/xorm/dialects/sqlite3.go
-
21vendor/xorm.io/xorm/dialects/table_name.go
-
16vendor/xorm.io/xorm/doc.go
-
371vendor/xorm.io/xorm/engine.go
-
10vendor/xorm.io/xorm/go.mod
-
136vendor/xorm.io/xorm/go.sum
-
3vendor/xorm.io/xorm/interface.go
-
43vendor/xorm.io/xorm/internal/statements/insert.go
-
75vendor/xorm.io/xorm/internal/statements/query.go
-
38vendor/xorm.io/xorm/internal/statements/statement.go
-
6vendor/xorm.io/xorm/internal/utils/name.go
-
14vendor/xorm.io/xorm/internal/utils/slice.go
-
16vendor/xorm.io/xorm/log/logger.go
-
17vendor/xorm.io/xorm/log/syslogger.go
-
43vendor/xorm.io/xorm/names/table_name.go
-
31vendor/xorm.io/xorm/rows.go
-
255vendor/xorm.io/xorm/scan.go
-
2vendor/xorm.io/xorm/schemas/index.go
-
10vendor/xorm.io/xorm/schemas/quote.go
-
9vendor/xorm.io/xorm/schemas/type.go
-
57vendor/xorm.io/xorm/session.go
-
14vendor/xorm.io/xorm/session_delete.go
@ -0,0 +1,875 @@ |
|||||
|
package encoder |
||||
|
|
||||
|
import ( |
||||
|
"fmt" |
||||
|
"unsafe" |
||||
|
|
||||
|
"github.com/goccy/go-json/internal/runtime" |
||||
|
) |
||||
|
|
||||
|
type Code interface { |
||||
|
Kind() CodeKind |
||||
|
ToOpcode(*compileContext) Opcodes |
||||
|
} |
||||
|
|
||||
|
type AnonymousCode interface { |
||||
|
ToAnonymousOpcode(*compileContext) Opcodes |
||||
|
} |
||||
|
|
||||
|
type Opcodes []*Opcode |
||||
|
|
||||
|
func (o Opcodes) First() *Opcode { |
||||
|
if len(o) == 0 { |
||||
|
return nil |
||||
|
} |
||||
|
return o[0] |
||||
|
} |
||||
|
|
||||
|
func (o Opcodes) Last() *Opcode { |
||||
|
if len(o) == 0 { |
||||
|
return nil |
||||
|
} |
||||
|
return o[len(o)-1] |
||||
|
} |
||||
|
|
||||
|
func (o Opcodes) Add(codes ...*Opcode) Opcodes { |
||||
|
return append(o, codes...) |
||||
|
} |
||||
|
|
||||
|
type CodeKind int |
||||
|
|
||||
|
const ( |
||||
|
CodeKindInterface CodeKind = iota |
||||
|
CodeKindPtr |
||||
|
CodeKindInt |
||||
|
CodeKindUint |
||||
|
CodeKindFloat |
||||
|
CodeKindString |
||||
|
CodeKindBool |
||||
|
CodeKindStruct |
||||
|
CodeKindMap |
||||
|
CodeKindSlice |
||||
|
CodeKindArray |
||||
|
CodeKindBytes |
||||
|
CodeKindMarshalJSON |
||||
|
CodeKindMarshalText |
||||
|
CodeKindRecursive |
||||
|
) |
||||
|
|
||||
|
type IntCode struct { |
||||
|
typ *runtime.Type |
||||
|
bitSize uint8 |
||||
|
isString bool |
||||
|
isPtr bool |
||||
|
} |
||||
|
|
||||
|
func (c *IntCode) Kind() CodeKind { |
||||
|
return CodeKindInt |
||||
|
} |
||||
|
|
||||
|
func (c *IntCode) ToOpcode(ctx *compileContext) Opcodes { |
||||
|
var code *Opcode |
||||
|
switch { |
||||
|
case c.isPtr: |
||||
|
code = newOpCode(ctx, c.typ, OpIntPtr) |
||||
|
case c.isString: |
||||
|
code = newOpCode(ctx, c.typ, OpIntString) |
||||
|
default: |
||||
|
code = newOpCode(ctx, c.typ, OpInt) |
||||
|
} |
||||
|
code.NumBitSize = c.bitSize |
||||
|
ctx.incIndex() |
||||
|
return Opcodes{code} |
||||
|
} |
||||
|
|
||||
|
type UintCode struct { |
||||
|
typ *runtime.Type |
||||
|
bitSize uint8 |
||||
|
isString bool |
||||
|
isPtr bool |
||||
|
} |
||||
|
|
||||
|
func (c *UintCode) Kind() CodeKind { |
||||
|
return CodeKindUint |
||||
|
} |
||||
|
|
||||
|
func (c *UintCode) ToOpcode(ctx *compileContext) Opcodes { |
||||
|
var code *Opcode |
||||
|
switch { |
||||
|
case c.isPtr: |
||||
|
code = newOpCode(ctx, c.typ, OpUintPtr) |
||||
|
case c.isString: |
||||
|
code = newOpCode(ctx, c.typ, OpUintString) |
||||
|
default: |
||||
|
code = newOpCode(ctx, c.typ, OpUint) |
||||
|
} |
||||
|
code.NumBitSize = c.bitSize |
||||
|
ctx.incIndex() |
||||
|
return Opcodes{code} |
||||
|
} |
||||
|
|
||||
|
type FloatCode struct { |
||||
|
typ *runtime.Type |
||||
|
bitSize uint8 |
||||
|
isPtr bool |
||||
|
} |
||||
|
|
||||
|
func (c *FloatCode) Kind() CodeKind { |
||||
|
return CodeKindFloat |
||||
|
} |
||||
|
|
||||
|
func (c *FloatCode) ToOpcode(ctx *compileContext) Opcodes { |
||||
|
var code *Opcode |
||||
|
switch { |
||||
|
case c.isPtr: |
||||
|
switch c.bitSize { |
||||
|
case 32: |
||||
|
code = newOpCode(ctx, c.typ, OpFloat32Ptr) |
||||
|
default: |
||||
|
code = newOpCode(ctx, c.typ, OpFloat64Ptr) |
||||
|
} |
||||
|
default: |
||||
|
switch c.bitSize { |
||||
|
case 32: |
||||
|
code = newOpCode(ctx, c.typ, OpFloat32) |
||||
|
default: |
||||
|
code = newOpCode(ctx, c.typ, OpFloat64) |
||||
|
} |
||||
|
} |
||||
|
ctx.incIndex() |
||||
|
return Opcodes{code} |
||||
|
} |
||||
|
|
||||
|
type StringCode struct { |
||||
|
typ *runtime.Type |
||||
|
isPtr bool |
||||
|
} |
||||
|
|
||||
|
func (c *StringCode) Kind() CodeKind { |
||||
|
return CodeKindString |
||||
|
} |
||||
|
|
||||
|
func (c *StringCode) ToOpcode(ctx *compileContext) Opcodes { |
||||
|
isJSONNumberType := c.typ == runtime.Type2RType(jsonNumberType) |
||||
|
var code *Opcode |
||||
|
if c.isPtr { |
||||
|
if isJSONNumberType { |
||||
|
code = newOpCode(ctx, c.typ, OpNumberPtr) |
||||
|
} else { |
||||
|
code = newOpCode(ctx, c.typ, OpStringPtr) |
||||
|
} |
||||
|
} else { |
||||
|
if isJSONNumberType { |
||||
|
code = newOpCode(ctx, c.typ, OpNumber) |
||||
|
} else { |
||||
|
code = newOpCode(ctx, c.typ, OpString) |
||||
|
} |
||||
|
} |
||||
|
ctx.incIndex() |
||||
|
return Opcodes{code} |
||||
|
} |
||||
|
|
||||
|
type BoolCode struct { |
||||
|
typ *runtime.Type |
||||
|
isPtr bool |
||||
|
} |
||||
|
|
||||
|
func (c *BoolCode) Kind() CodeKind { |
||||
|
return CodeKindBool |
||||
|
} |
||||
|
|
||||
|
func (c *BoolCode) ToOpcode(ctx *compileContext) Opcodes { |
||||
|
var code *Opcode |
||||
|
switch { |
||||
|
case c.isPtr: |
||||
|
code = newOpCode(ctx, c.typ, OpBoolPtr) |
||||
|
default: |
||||
|
code = newOpCode(ctx, c.typ, OpBool) |
||||
|
} |
||||
|
ctx.incIndex() |
||||
|
return Opcodes{code} |
||||
|
} |
||||
|
|
||||
|
type BytesCode struct { |
||||
|
typ *runtime.Type |
||||
|
isPtr bool |
||||
|
} |
||||
|
|
||||
|
func (c *BytesCode) Kind() CodeKind { |
||||
|
return CodeKindBytes |
||||
|
} |
||||
|
|
||||
|
func (c *BytesCode) ToOpcode(ctx *compileContext) Opcodes { |
||||
|
var code *Opcode |
||||
|
switch { |
||||
|
case c.isPtr: |
||||
|
code = newOpCode(ctx, c.typ, OpBytesPtr) |
||||
|
default: |
||||
|
code = newOpCode(ctx, c.typ, OpBytes) |
||||
|
} |
||||
|
ctx.incIndex() |
||||
|
return Opcodes{code} |
||||
|
} |
||||
|
|
||||
|
type SliceCode struct { |
||||
|
typ *runtime.Type |
||||
|
value Code |
||||
|
} |
||||
|
|
||||
|
func (c *SliceCode) Kind() CodeKind { |
||||
|
return CodeKindSlice |
||||
|
} |
||||
|
|
||||
|
func (c *SliceCode) ToOpcode(ctx *compileContext) Opcodes { |
||||
|
// header => opcode => elem => end
|
||||
|
// ^ |
|
||||
|
// |________|
|
||||
|
size := c.typ.Elem().Size() |
||||
|
header := newSliceHeaderCode(ctx, c.typ) |
||||
|
ctx.incIndex() |
||||
|
|
||||
|
ctx.incIndent() |
||||
|
codes := c.value.ToOpcode(ctx) |
||||
|
ctx.decIndent() |
||||
|
|
||||
|
codes.First().Flags |= IndirectFlags |
||||
|
elemCode := newSliceElemCode(ctx, c.typ.Elem(), header, size) |
||||
|
ctx.incIndex() |
||||
|
end := newOpCode(ctx, c.typ, OpSliceEnd) |
||||
|
ctx.incIndex() |
||||
|
header.End = end |
||||
|
header.Next = codes.First() |
||||
|
codes.Last().Next = elemCode |
||||
|
elemCode.Next = codes.First() |
||||
|
elemCode.End = end |
||||
|
return Opcodes{header}.Add(codes...).Add(elemCode).Add(end) |
||||
|
} |
||||
|
|
||||
|
type ArrayCode struct { |
||||
|
typ *runtime.Type |
||||
|
value Code |
||||
|
} |
||||
|
|
||||
|
func (c *ArrayCode) Kind() CodeKind { |
||||
|
return CodeKindArray |
||||
|
} |
||||
|
|
||||
|
func (c *ArrayCode) ToOpcode(ctx *compileContext) Opcodes { |
||||
|
// header => opcode => elem => end
|
||||
|
// ^ |
|
||||
|
// |________|
|
||||
|
elem := c.typ.Elem() |
||||
|
alen := c.typ.Len() |
||||
|
size := elem.Size() |
||||
|
|
||||
|
header := newArrayHeaderCode(ctx, c.typ, alen) |
||||
|
ctx.incIndex() |
||||
|
|
||||
|
ctx.incIndent() |
||||
|
codes := c.value.ToOpcode(ctx) |
||||
|
ctx.decIndent() |
||||
|
|
||||
|
codes.First().Flags |= IndirectFlags |
||||
|
|
||||
|
elemCode := newArrayElemCode(ctx, elem, header, alen, size) |
||||
|
ctx.incIndex() |
||||
|
|
||||
|
end := newOpCode(ctx, c.typ, OpArrayEnd) |
||||
|
ctx.incIndex() |
||||
|
|
||||
|
header.End = end |
||||
|
header.Next = codes.First() |
||||
|
codes.Last().Next = elemCode |
||||
|
elemCode.Next = codes.First() |
||||
|
elemCode.End = end |
||||
|
|
||||
|
return Opcodes{header}.Add(codes...).Add(elemCode).Add(end) |
||||
|
} |
||||
|
|
||||
|
type MapCode struct { |
||||
|
typ *runtime.Type |
||||
|
key Code |
||||
|
value Code |
||||
|
} |
||||
|
|
||||
|
func (c *MapCode) Kind() CodeKind { |
||||
|
return CodeKindMap |
||||
|
} |
||||
|
|
||||
|
func (c *MapCode) ToOpcode(ctx *compileContext) Opcodes { |
||||
|
// header => code => value => code => key => code => value => code => end
|
||||
|
// ^ |
|
||||
|
// |_______________________|
|
||||
|
header := newMapHeaderCode(ctx, c.typ) |
||||
|
ctx.incIndex() |
||||
|
|
||||
|
keyCodes := c.key.ToOpcode(ctx) |
||||
|
|
||||
|
value := newMapValueCode(ctx, c.typ.Elem(), header) |
||||
|
ctx.incIndex() |
||||
|
|
||||
|
ctx.incIndent() |
||||
|
valueCodes := c.value.ToOpcode(ctx) |
||||
|
ctx.decIndent() |
||||
|
|
||||
|
valueCodes.First().Flags |= IndirectFlags |
||||
|
|
||||
|
key := newMapKeyCode(ctx, c.typ.Key(), header) |
||||
|
ctx.incIndex() |
||||
|
|
||||
|
end := newMapEndCode(ctx, c.typ, header) |
||||
|
ctx.incIndex() |
||||
|
|
||||
|
header.Next = keyCodes.First() |
||||
|
keyCodes.Last().Next = value |
||||
|
value.Next = valueCodes.First() |
||||
|
valueCodes.Last().Next = key |
||||
|
key.Next = keyCodes.First() |
||||
|
|
||||
|
header.End = end |
||||
|
key.End = end |
||||
|
value.End = end |
||||
|
return Opcodes{header}.Add(keyCodes...).Add(value).Add(valueCodes...).Add(key).Add(end) |
||||
|
} |
||||
|
|
||||
|
type StructCode struct { |
||||
|
typ *runtime.Type |
||||
|
fields []*StructFieldCode |
||||
|
isPtr bool |
||||
|
disableIndirectConversion bool |
||||
|
isIndirect bool |
||||
|
isRecursive bool |
||||
|
} |
||||
|
|
||||
|
func (c *StructCode) Kind() CodeKind { |
||||
|
return CodeKindStruct |
||||
|
} |
||||
|
|
||||
|
func (c *StructCode) lastFieldCode(field *StructFieldCode, firstField *Opcode) *Opcode { |
||||
|
if field.isAnonymous { |
||||
|
return c.lastAnonymousFieldCode(firstField) |
||||
|
} |
||||
|
lastField := firstField |
||||
|
for lastField.NextField != nil { |
||||
|
lastField = lastField.NextField |
||||
|
} |
||||
|
return lastField |
||||
|
} |
||||
|
|
||||
|
func (c *StructCode) lastAnonymousFieldCode(firstField *Opcode) *Opcode { |
||||
|
// firstField is special StructHead operation for anonymous structure.
|
||||
|
// So, StructHead's next operation is truly struct head operation.
|
||||
|
lastField := firstField.Next |
||||
|
for lastField.NextField != nil { |
||||
|
lastField = lastField.NextField |
||||
|
} |
||||
|
return lastField |
||||
|
} |
||||
|
|
||||
|
func (c *StructCode) ToOpcode(ctx *compileContext) Opcodes { |
||||
|
// header => code => structField => code => end
|
||||
|
// ^ |
|
||||
|
// |__________|
|
||||
|
if c.isRecursive { |
||||
|
recursive := newRecursiveCode(ctx, c.typ, &CompiledCode{}) |
||||
|
recursive.Type = c.typ |
||||
|
ctx.incIndex() |
||||
|
*ctx.recursiveCodes = append(*ctx.recursiveCodes, recursive) |
||||
|
return Opcodes{recursive} |
||||
|
} |
||||
|
codes := Opcodes{} |
||||
|
var prevField *Opcode |
||||
|
ctx.incIndent() |
||||
|
for idx, field := range c.fields { |
||||
|
isFirstField := idx == 0 |
||||
|
isEndField := idx == len(c.fields)-1 |
||||
|
fieldCodes := field.ToOpcode(ctx, isFirstField, isEndField) |
||||
|
for _, code := range fieldCodes { |
||||
|
if c.isIndirect { |
||||
|
code.Flags |= IndirectFlags |
||||
|
} |
||||
|
} |
||||
|
firstField := fieldCodes.First() |
||||
|
if len(codes) > 0 { |
||||
|
codes.Last().Next = firstField |
||||
|
firstField.Idx = codes.First().Idx |
||||
|
} |
||||
|
if prevField != nil { |
||||
|
prevField.NextField = firstField |
||||
|
} |
||||
|
if isEndField { |
||||
|
endField := fieldCodes.Last() |
||||
|
if len(codes) > 0 { |
||||
|
codes.First().End = endField |
||||
|
} else if field.isAnonymous { |
||||
|
firstField.End = endField |
||||
|
lastField := c.lastAnonymousFieldCode(firstField) |
||||
|
lastField.NextField = endField |
||||
|
} else { |
||||
|
firstField.End = endField |
||||
|
} |
||||
|
codes = codes.Add(fieldCodes...) |
||||
|
break |
||||
|
} |
||||
|
prevField = c.lastFieldCode(field, firstField) |
||||
|
codes = codes.Add(fieldCodes...) |
||||
|
} |
||||
|
if len(codes) == 0 { |
||||
|
head := &Opcode{ |
||||
|
Op: OpStructHead, |
||||
|
Idx: opcodeOffset(ctx.ptrIndex), |
||||
|
Type: c.typ, |
||||
|
DisplayIdx: ctx.opcodeIndex, |
||||
|
Indent: ctx.indent, |
||||
|
} |
||||
|
ctx.incOpcodeIndex() |
||||
|
end := &Opcode{ |
||||
|
Op: OpStructEnd, |
||||
|
Idx: opcodeOffset(ctx.ptrIndex), |
||||
|
DisplayIdx: ctx.opcodeIndex, |
||||
|
Indent: ctx.indent, |
||||
|
} |
||||
|
head.NextField = end |
||||
|
head.Next = end |
||||
|
head.End = end |
||||
|
codes = codes.Add(head, end) |
||||
|
ctx.incIndex() |
||||
|
} |
||||
|
ctx.decIndent() |
||||
|
ctx.structTypeToCodes[uintptr(unsafe.Pointer(c.typ))] = codes |
||||
|
return codes |
||||
|
} |
||||
|
|
||||
|
func (c *StructCode) ToAnonymousOpcode(ctx *compileContext) Opcodes { |
||||
|
// header => code => structField => code => end
|
||||
|
// ^ |
|
||||
|
// |__________|
|
||||
|
if c.isRecursive { |
||||
|
recursive := newRecursiveCode(ctx, c.typ, &CompiledCode{}) |
||||
|
recursive.Type = c.typ |
||||
|
ctx.incIndex() |
||||
|
*ctx.recursiveCodes = append(*ctx.recursiveCodes, recursive) |
||||
|
return Opcodes{recursive} |
||||
|
} |
||||
|
codes := Opcodes{} |
||||
|
var prevField *Opcode |
||||
|
for idx, field := range c.fields { |
||||
|
isFirstField := idx == 0 |
||||
|
isEndField := idx == len(c.fields)-1 |
||||
|
fieldCodes := field.ToAnonymousOpcode(ctx, isFirstField, isEndField) |
||||
|
for _, code := range fieldCodes { |
||||
|
if c.isIndirect { |
||||
|
code.Flags |= IndirectFlags |
||||
|
} |
||||
|
} |
||||
|
firstField := fieldCodes.First() |
||||
|
if len(codes) > 0 { |
||||
|
codes.Last().Next = firstField |
||||
|
firstField.Idx = codes.First().Idx |
||||
|
} |
||||
|
if prevField != nil { |
||||
|
prevField.NextField = firstField |
||||
|
} |
||||
|
if isEndField { |
||||
|
lastField := fieldCodes.Last() |
||||
|
if len(codes) > 0 { |
||||
|
codes.First().End = lastField |
||||
|
} else { |
||||
|
firstField.End = lastField |
||||
|
} |
||||
|
} |
||||
|
prevField = firstField |
||||
|
codes = codes.Add(fieldCodes...) |
||||
|
} |
||||
|
return codes |
||||
|
} |
||||
|
|
||||
|
func (c *StructCode) removeFieldsByTags(tags runtime.StructTags) { |
||||
|
fields := make([]*StructFieldCode, 0, len(c.fields)) |
||||
|
for _, field := range c.fields { |
||||
|
if field.isAnonymous { |
||||
|
structCode := field.getAnonymousStruct() |
||||
|
if structCode != nil && !structCode.isRecursive { |
||||
|
structCode.removeFieldsByTags(tags) |
||||
|
if len(structCode.fields) > 0 { |
||||
|
fields = append(fields, field) |
||||
|
} |
||||
|
continue |
||||
|
} |
||||
|
} |
||||
|
if tags.ExistsKey(field.key) { |
||||
|
continue |
||||
|
} |
||||
|
fields = append(fields, field) |
||||
|
} |
||||
|
c.fields = fields |
||||
|
} |
||||
|
|
||||
|
func (c *StructCode) enableIndirect() { |
||||
|
if c.isIndirect { |
||||
|
return |
||||
|
} |
||||
|
c.isIndirect = true |
||||
|
if len(c.fields) == 0 { |
||||
|
return |
||||
|
} |
||||
|
structCode := c.fields[0].getStruct() |
||||
|
if structCode == nil { |
||||
|
return |
||||
|
} |
||||
|
structCode.enableIndirect() |
||||
|
} |
||||
|
|
||||
|
type StructFieldCode struct { |
||||
|
typ *runtime.Type |
||||
|
key string |
||||
|
tag *runtime.StructTag |
||||
|
value Code |
||||
|
offset uintptr |
||||
|
isAnonymous bool |
||||
|
isTaggedKey bool |
||||
|
isNilableType bool |
||||
|
isNilCheck bool |
||||
|
isAddrForMarshaler bool |
||||
|
isNextOpPtrType bool |
||||
|
} |
||||
|
|
||||
|
func (c *StructFieldCode) getStruct() *StructCode { |
||||
|
value := c.value |
||||
|
ptr, ok := value.(*PtrCode) |
||||
|
if ok { |
||||
|
value = ptr.value |
||||
|
} |
||||
|
structCode, ok := value.(*StructCode) |
||||
|
if ok { |
||||
|
return structCode |
||||
|
} |
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
func (c *StructFieldCode) getAnonymousStruct() *StructCode { |
||||
|
if !c.isAnonymous { |
||||
|
return nil |
||||
|
} |
||||
|
return c.getStruct() |
||||
|
} |
||||
|
|
||||
|
func optimizeStructHeader(code *Opcode, tag *runtime.StructTag) OpType { |
||||
|
headType := code.ToHeaderType(tag.IsString) |
||||
|
if tag.IsOmitEmpty { |
||||
|
headType = headType.HeadToOmitEmptyHead() |
||||
|
} |
||||
|
return headType |
||||
|
} |
||||
|
|
||||
|
func optimizeStructField(code *Opcode, tag *runtime.StructTag) OpType { |
||||
|
fieldType := code.ToFieldType(tag.IsString) |
||||
|
if tag.IsOmitEmpty { |
||||
|
fieldType = fieldType.FieldToOmitEmptyField() |
||||
|
} |
||||
|
return fieldType |
||||
|
} |
||||
|
|
||||
|
func (c *StructFieldCode) headerOpcodes(ctx *compileContext, field *Opcode, valueCodes Opcodes) Opcodes { |
||||
|
value := valueCodes.First() |
||||
|
op := optimizeStructHeader(value, c.tag) |
||||
|
field.Op = op |
||||
|
field.NumBitSize = value.NumBitSize |
||||
|
field.PtrNum = value.PtrNum |
||||
|
fieldCodes := Opcodes{field} |
||||
|
if op.IsMultipleOpHead() { |
||||
|
field.Next = value |
||||
|
fieldCodes = fieldCodes.Add(valueCodes...) |
||||
|
} else { |
||||
|
ctx.decIndex() |
||||
|
} |
||||
|
return fieldCodes |
||||
|
} |
||||
|
|
||||
|
func (c *StructFieldCode) fieldOpcodes(ctx *compileContext, field *Opcode, valueCodes Opcodes) Opcodes { |
||||
|
value := valueCodes.First() |
||||
|
op := optimizeStructField(value, c.tag) |
||||
|
field.Op = op |
||||
|
field.NumBitSize = value.NumBitSize |
||||
|
field.PtrNum = value.PtrNum |
||||
|
|
||||
|
fieldCodes := Opcodes{field} |
||||
|
if op.IsMultipleOpField() { |
||||
|
field.Next = value |
||||
|
fieldCodes = fieldCodes.Add(valueCodes...) |
||||
|
} else { |
||||
|
ctx.decIndex() |
||||
|
} |
||||
|
return fieldCodes |
||||
|
} |
||||
|
|
||||
|
func (c *StructFieldCode) addStructEndCode(ctx *compileContext, codes Opcodes) Opcodes { |
||||
|
end := &Opcode{ |
||||
|
Op: OpStructEnd, |
||||
|
Idx: opcodeOffset(ctx.ptrIndex), |
||||
|
DisplayIdx: ctx.opcodeIndex, |
||||
|
Indent: ctx.indent, |
||||
|
} |
||||
|
codes.Last().Next = end |
||||
|
codes.First().NextField = end |
||||
|
codes = codes.Add(end) |
||||
|
ctx.incOpcodeIndex() |
||||
|
return codes |
||||
|
} |
||||
|
|
||||
|
func (c *StructFieldCode) structKey(ctx *compileContext) string { |
||||
|
if ctx.escapeKey { |
||||
|
rctx := &RuntimeContext{Option: &Option{Flag: HTMLEscapeOption}} |
||||
|
return fmt.Sprintf(`%s:`, string(AppendString(rctx, []byte{}, c.key))) |
||||
|
} |
||||
|
return fmt.Sprintf(`"%s":`, c.key) |
||||
|
} |
||||
|
|
||||
|
func (c *StructFieldCode) flags() OpFlags { |
||||
|
var flags OpFlags |
||||
|
if c.isTaggedKey { |
||||
|
flags |= IsTaggedKeyFlags |
||||
|
} |
||||
|
if c.isNilableType { |
||||
|
flags |= IsNilableTypeFlags |
||||
|
} |
||||
|
if c.isNilCheck { |
||||
|
flags |= NilCheckFlags |
||||
|
} |
||||
|
if c.isAddrForMarshaler { |
||||
|
flags |= AddrForMarshalerFlags |
||||
|
} |
||||
|
if c.isNextOpPtrType { |
||||
|
flags |= IsNextOpPtrTypeFlags |
||||
|
} |
||||
|
if c.isAnonymous { |
||||
|
flags |= AnonymousKeyFlags |
||||
|
} |
||||
|
return flags |
||||
|
} |
||||
|
|
||||
|
func (c *StructFieldCode) toValueOpcodes(ctx *compileContext) Opcodes { |
||||
|
if c.isAnonymous { |
||||
|
anonymCode, ok := c.value.(AnonymousCode) |
||||
|
if ok { |
||||
|
return anonymCode.ToAnonymousOpcode(ctx) |
||||
|
} |
||||
|
} |
||||
|
return c.value.ToOpcode(ctx) |
||||
|
} |
||||
|
|
||||
|
func (c *StructFieldCode) ToOpcode(ctx *compileContext, isFirstField, isEndField bool) Opcodes { |
||||
|
field := &Opcode{ |
||||
|
Idx: opcodeOffset(ctx.ptrIndex), |
||||
|
Flags: c.flags(), |
||||
|
Key: c.structKey(ctx), |
||||
|
Offset: uint32(c.offset), |
||||
|
Type: c.typ, |
||||
|
DisplayIdx: ctx.opcodeIndex, |
||||
|
Indent: ctx.indent, |
||||
|
DisplayKey: c.key, |
||||
|
} |
||||
|
ctx.incIndex() |
||||
|
valueCodes := c.toValueOpcodes(ctx) |
||||
|
if isFirstField { |
||||
|
codes := c.headerOpcodes(ctx, field, valueCodes) |
||||
|
if isEndField { |
||||
|
codes = c.addStructEndCode(ctx, codes) |
||||
|
} |
||||
|
return codes |
||||
|
} |
||||
|
codes := c.fieldOpcodes(ctx, field, valueCodes) |
||||
|
if isEndField { |
||||
|
if isEnableStructEndOptimization(c.value) { |
||||
|
field.Op = field.Op.FieldToEnd() |
||||
|
} else { |
||||
|
codes = c.addStructEndCode(ctx, codes) |
||||
|
} |
||||
|
} |
||||
|
return codes |
||||
|
} |
||||
|
|
||||
|
func (c *StructFieldCode) ToAnonymousOpcode(ctx *compileContext, isFirstField, isEndField bool) Opcodes { |
||||
|
field := &Opcode{ |
||||
|
Idx: opcodeOffset(ctx.ptrIndex), |
||||
|
Flags: c.flags() | AnonymousHeadFlags, |
||||
|
Key: c.structKey(ctx), |
||||
|
Offset: uint32(c.offset), |
||||
|
Type: c.typ, |
||||
|
DisplayIdx: ctx.opcodeIndex, |
||||
|
Indent: ctx.indent, |
||||
|
DisplayKey: c.key, |
||||
|
} |
||||
|
ctx.incIndex() |
||||
|
valueCodes := c.toValueOpcodes(ctx) |
||||
|
if isFirstField { |
||||
|
return c.headerOpcodes(ctx, field, valueCodes) |
||||
|
} |
||||
|
return c.fieldOpcodes(ctx, field, valueCodes) |
||||
|
} |
||||
|
|
||||
|
func isEnableStructEndOptimization(value Code) bool { |
||||
|
switch value.Kind() { |
||||
|
case CodeKindInt, |
||||
|
CodeKindUint, |
||||
|
CodeKindFloat, |
||||
|
CodeKindString, |
||||
|
CodeKindBool, |
||||
|
CodeKindBytes: |
||||
|
return true |
||||
|
case CodeKindPtr: |
||||
|
return isEnableStructEndOptimization(value.(*PtrCode).value) |
||||
|
default: |
||||
|
return false |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
type InterfaceCode struct { |
||||
|
typ *runtime.Type |
||||
|
isPtr bool |
||||
|
} |
||||
|
|
||||
|
func (c *InterfaceCode) Kind() CodeKind { |
||||
|
return CodeKindInterface |
||||
|
} |
||||
|
|
||||
|
func (c *InterfaceCode) ToOpcode(ctx *compileContext) Opcodes { |
||||
|
var code *Opcode |
||||
|
switch { |
||||
|
case c.isPtr: |
||||
|
code = newOpCode(ctx, c.typ, OpInterfacePtr) |
||||
|
default: |
||||
|
code = newOpCode(ctx, c.typ, OpInterface) |
||||
|
} |
||||
|
if c.typ.NumMethod() > 0 { |
||||
|
code.Flags |= NonEmptyInterfaceFlags |
||||
|
} |
||||
|
ctx.incIndex() |
||||
|
return Opcodes{code} |
||||
|
} |
||||
|
|
||||
|
type MarshalJSONCode struct { |
||||
|
typ *runtime.Type |
||||
|
isAddrForMarshaler bool |
||||
|
isNilableType bool |
||||
|
isMarshalerContext bool |
||||
|
} |
||||
|
|
||||
|
func (c *MarshalJSONCode) Kind() CodeKind { |
||||
|
return CodeKindMarshalJSON |
||||
|
} |
||||
|
|
||||
|
func (c *MarshalJSONCode) ToOpcode(ctx *compileContext) Opcodes { |
||||
|
code := newOpCode(ctx, c.typ, OpMarshalJSON) |
||||
|
if c.isAddrForMarshaler { |
||||
|
code.Flags |= AddrForMarshalerFlags |
||||
|
} |
||||
|
if c.isMarshalerContext { |
||||
|
code.Flags |= MarshalerContextFlags |
||||
|
} |
||||
|
if c.isNilableType { |
||||
|
code.Flags |= IsNilableTypeFlags |
||||
|
} else { |
||||
|
code.Flags &= ^IsNilableTypeFlags |
||||
|
} |
||||
|
ctx.incIndex() |
||||
|
return Opcodes{code} |
||||
|
} |
||||
|
|
||||
|
type MarshalTextCode struct { |
||||
|
typ *runtime.Type |
||||
|
isAddrForMarshaler bool |
||||
|
isNilableType bool |
||||
|
} |
||||
|
|
||||
|
func (c *MarshalTextCode) Kind() CodeKind { |
||||
|
return CodeKindMarshalText |
||||
|
} |
||||
|
|
||||
|
func (c *MarshalTextCode) ToOpcode(ctx *compileContext) Opcodes { |
||||
|
code := newOpCode(ctx, c.typ, OpMarshalText) |
||||
|
if c.isAddrForMarshaler { |
||||
|
code.Flags |= AddrForMarshalerFlags |
||||
|
} |
||||
|
if c.isNilableType { |
||||
|
code.Flags |= IsNilableTypeFlags |
||||
|
} else { |
||||
|
code.Flags &= ^IsNilableTypeFlags |
||||
|
} |
||||
|
ctx.incIndex() |
||||
|
return Opcodes{code} |
||||
|
} |
||||
|
|
||||
|
type PtrCode struct { |
||||
|
typ *runtime.Type |
||||
|
value Code |
||||
|
ptrNum uint8 |
||||
|
} |
||||
|
|
||||
|
func (c *PtrCode) Kind() CodeKind { |
||||
|
return CodeKindPtr |
||||
|
} |
||||
|
|
||||
|
func (c *PtrCode) ToOpcode(ctx *compileContext) Opcodes { |
||||
|
codes := c.value.ToOpcode(ctx) |
||||
|
codes.First().Op = convertPtrOp(codes.First()) |
||||
|
codes.First().PtrNum = c.ptrNum |
||||
|
return codes |
||||
|
} |
||||
|
|
||||
|
func (c *PtrCode) ToAnonymousOpcode(ctx *compileContext) Opcodes { |
||||
|
var codes Opcodes |
||||
|
anonymCode, ok := c.value.(AnonymousCode) |
||||
|
if ok { |
||||
|
codes = anonymCode.ToAnonymousOpcode(ctx) |
||||
|
} else { |
||||
|
codes = c.value.ToOpcode(ctx) |
||||
|
} |
||||
|
codes.First().Op = convertPtrOp(codes.First()) |
||||
|
codes.First().PtrNum = c.ptrNum |
||||
|
return codes |
||||
|
} |
||||
|
|
||||
|
func convertPtrOp(code *Opcode) OpType { |
||||
|
ptrHeadOp := code.Op.HeadToPtrHead() |
||||
|
if code.Op != ptrHeadOp { |
||||
|
if code.PtrNum > 0 { |
||||
|
// ptr field and ptr head
|
||||
|
code.PtrNum-- |
||||
|
} |
||||
|
return ptrHeadOp |
||||
|
} |
||||
|
switch code.Op { |
||||
|
case OpInt: |
||||
|
return OpIntPtr |
||||
|
case OpUint: |
||||
|
return OpUintPtr |
||||
|
case OpFloat32: |
||||
|
return OpFloat32Ptr |
||||
|
case OpFloat64: |
||||
|
return OpFloat64Ptr |
||||
|
case OpString: |
||||
|
return OpStringPtr |
||||
|
case OpBool: |
||||
|
return OpBoolPtr |
||||
|
case OpBytes: |
||||
|
return OpBytesPtr |
||||
|
case OpNumber: |
||||
|
return OpNumberPtr |
||||
|
case OpArray: |
||||
|
return OpArrayPtr |
||||
|
case OpSlice: |
||||
|
return OpSlicePtr |
||||
|
case OpMap: |
||||
|
return OpMapPtr |
||||
|
case OpMarshalJSON: |
||||
|
return OpMarshalJSONPtr |
||||
|
case OpMarshalText: |
||||
|
return OpMarshalTextPtr |
||||
|
case OpInterface: |
||||
|
return OpInterfacePtr |
||||
|
case OpRecursive: |
||||
|
return OpRecursivePtr |
||||
|
} |
||||
|
return code.Op |
||||
|
} |
||||
1721
vendor/github.com/goccy/go-json/internal/encoder/compiler.go
File diff suppressed because it is too large
View File
File diff suppressed because it is too large
View File
703
vendor/github.com/goccy/go-json/internal/encoder/vm/vm.go
File diff suppressed because it is too large
View File
File diff suppressed because it is too large
View File
703
vendor/github.com/goccy/go-json/internal/encoder/vm_color/vm.go
File diff suppressed because it is too large
View File
File diff suppressed because it is too large
View File
703
vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/vm.go
File diff suppressed because it is too large
View File
File diff suppressed because it is too large
View File
703
vendor/github.com/goccy/go-json/internal/encoder/vm_indent/vm.go
File diff suppressed because it is too large
View File
File diff suppressed because it is too large
View File
@ -0,0 +1,494 @@ |
|||||
|
// Copyright 2020 The Go Authors. All rights reserved. |
||||
|
// Use of this source code is governed by a BSD-style |
||||
|
// license that can be found in the LICENSE file. |
||||
|
|
||||
|
// +build !appengine |
||||
|
// +build gc |
||||
|
// +build !noasm |
||||
|
|
||||
|
#include "textflag.h" |
||||
|
|
||||
|
// The asm code generally follows the pure Go code in decode_other.go, except |
||||
|
// where marked with a "!!!". |
||||
|
|
||||
|
// func decode(dst, src []byte) int |
||||
|
// |
||||
|
// All local variables fit into registers. The non-zero stack size is only to |
||||
|
// spill registers and push args when issuing a CALL. The register allocation: |
||||
|
// - R2 scratch |
||||
|
// - R3 scratch |
||||
|
// - R4 length or x |
||||
|
// - R5 offset |
||||
|
// - R6 &src[s] |
||||
|
// - R7 &dst[d] |
||||
|
// + R8 dst_base |
||||
|
// + R9 dst_len |
||||
|
// + R10 dst_base + dst_len |
||||
|
// + R11 src_base |
||||
|
// + R12 src_len |
||||
|
// + R13 src_base + src_len |
||||
|
// - R14 used by doCopy |
||||
|
// - R15 used by doCopy |
||||
|
// |
||||
|
// The registers R8-R13 (marked with a "+") are set at the start of the |
||||
|
// function, and after a CALL returns, and are not otherwise modified. |
||||
|
// |
||||
|
// The d variable is implicitly R7 - R8, and len(dst)-d is R10 - R7. |
||||
|
// The s variable is implicitly R6 - R11, and len(src)-s is R13 - R6. |
||||
|
TEXT ·decode(SB), NOSPLIT, $56-56 |
||||
|
// Initialize R6, R7 and R8-R13. |
||||
|
MOVD dst_base+0(FP), R8 |
||||
|
MOVD dst_len+8(FP), R9 |
||||
|
MOVD R8, R7 |
||||
|
MOVD R8, R10 |
||||
|
ADD R9, R10, R10 |
||||
|
MOVD src_base+24(FP), R11 |
||||
|
MOVD src_len+32(FP), R12 |
||||
|
MOVD R11, R6 |
||||
|
MOVD R11, R13 |
||||
|
ADD R12, R13, R13 |
||||
|
|
||||
|
loop: |
||||
|
// for s < len(src) |
||||
|
CMP R13, R6 |
||||
|
BEQ end |
||||
|
|
||||
|
// R4 = uint32(src[s]) |
||||
|
// |
||||
|
// switch src[s] & 0x03 |
||||
|
MOVBU (R6), R4 |
||||
|
MOVW R4, R3 |
||||
|
ANDW $3, R3 |
||||
|
MOVW $1, R1 |
||||
|
CMPW R1, R3 |
||||
|
BGE tagCopy |
||||
|
|
||||
|
// ---------------------------------------- |
||||
|
// The code below handles literal tags. |
||||
|
|
||||
|
// case tagLiteral: |
||||
|
// x := uint32(src[s] >> 2) |
||||
|
// switch |
||||
|
MOVW $60, R1 |
||||
|
LSRW $2, R4, R4 |
||||
|
CMPW R4, R1 |
||||
|
BLS tagLit60Plus |
||||
|
|
||||
|
// case x < 60: |
||||
|
// s++ |
||||
|
ADD $1, R6, R6 |
||||
|
|
||||
|
doLit: |
||||
|
// This is the end of the inner "switch", when we have a literal tag. |
||||
|
// |
||||
|
// We assume that R4 == x and x fits in a uint32, where x is the variable |
||||
|
// used in the pure Go decode_other.go code. |
||||
|
|
||||
|
// length = int(x) + 1 |
||||
|
// |
||||
|
// Unlike the pure Go code, we don't need to check if length <= 0 because |
||||
|
// R4 can hold 64 bits, so the increment cannot overflow. |
||||
|
ADD $1, R4, R4 |
||||
|
|
||||
|
// Prepare to check if copying length bytes will run past the end of dst or |
||||
|
// src. |
||||
|
// |
||||
|
// R2 = len(dst) - d |
||||
|
// R3 = len(src) - s |
||||
|
MOVD R10, R2 |
||||
|
SUB R7, R2, R2 |
||||
|
MOVD R13, R3 |
||||
|
SUB R6, R3, R3 |
||||
|
|
||||
|
// !!! Try a faster technique for short (16 or fewer bytes) copies. |
||||
|
// |
||||
|
// if length > 16 || len(dst)-d < 16 || len(src)-s < 16 { |
||||
|
// goto callMemmove // Fall back on calling runtime·memmove. |
||||
|
// } |
||||
|
// |
||||
|
// The C++ snappy code calls this TryFastAppend. It also checks len(src)-s |
||||
|
// against 21 instead of 16, because it cannot assume that all of its input |
||||
|
// is contiguous in memory and so it needs to leave enough source bytes to |
||||
|
// read the next tag without refilling buffers, but Go's Decode assumes |
||||
|
// contiguousness (the src argument is a []byte). |
||||
|
CMP $16, R4 |
||||
|
BGT callMemmove |
||||
|
CMP $16, R2 |
||||
|
BLT callMemmove |
||||
|
CMP $16, R3 |
||||
|
BLT callMemmove |
||||
|
|
||||
|
// !!! Implement the copy from src to dst as a 16-byte load and store. |
||||
|
// (Decode's documentation says that dst and src must not overlap.) |
||||
|
// |
||||
|
// This always copies 16 bytes, instead of only length bytes, but that's |
||||
|
// OK. If the input is a valid Snappy encoding then subsequent iterations |
||||
|
// will fix up the overrun. Otherwise, Decode returns a nil []byte (and a |
||||
|
// non-nil error), so the overrun will be ignored. |
||||
|
// |
||||
|
// Note that on arm64, it is legal and cheap to issue unaligned 8-byte or |
||||
|
// 16-byte loads and stores. This technique probably wouldn't be as |
||||
|
// effective on architectures that are fussier about alignment. |
||||
|
LDP 0(R6), (R14, R15) |
||||
|
STP (R14, R15), 0(R7) |
||||
|
|
||||
|
// d += length |
||||
|
// s += length |
||||
|
ADD R4, R7, R7 |
||||
|
ADD R4, R6, R6 |
||||
|
B loop |
||||
|
|
||||
|
callMemmove: |
||||
|
// if length > len(dst)-d || length > len(src)-s { etc } |
||||
|
CMP R2, R4 |
||||
|
BGT errCorrupt |
||||
|
CMP R3, R4 |
||||
|
BGT errCorrupt |
||||
|
|
||||
|
// copy(dst[d:], src[s:s+length]) |
||||
|
// |
||||
|
// This means calling runtime·memmove(&dst[d], &src[s], length), so we push |
||||
|
// R7, R6 and R4 as arguments. Coincidentally, we also need to spill those |
||||
|
// three registers to the stack, to save local variables across the CALL. |
||||
|
MOVD R7, 8(RSP) |
||||
|
MOVD R6, 16(RSP) |
||||
|
MOVD R4, 24(RSP) |
||||
|
MOVD R7, 32(RSP) |
||||
|
MOVD R6, 40(RSP) |
||||
|
MOVD R4, 48(RSP) |
||||
|
CALL runtime·memmove(SB) |
||||
|
|
||||
|
// Restore local variables: unspill registers from the stack and |
||||
|
// re-calculate R8-R13. |
||||
|
MOVD 32(RSP), R7 |
||||
|
MOVD 40(RSP), R6 |
||||
|
MOVD 48(RSP), R4 |
||||
|
MOVD dst_base+0(FP), R8 |
||||
|
MOVD dst_len+8(FP), R9 |
||||
|
MOVD R8, R10 |
||||
|
ADD R9, R10, R10 |
||||
|
MOVD src_base+24(FP), R11 |
||||
|
MOVD src_len+32(FP), R12 |
||||
|
MOVD R11, R13 |
||||
|
ADD R12, R13, R13 |
||||
|
|
||||
|
// d += length |
||||
|
// s += length |
||||
|
ADD R4, R7, R7 |
||||
|
ADD R4, R6, R6 |
||||
|
B loop |
||||
|
|
||||
|
tagLit60Plus: |
||||
|
// !!! This fragment does the |
||||
|
// |
||||
|
// s += x - 58; if uint(s) > uint(len(src)) { etc } |
||||
|
// |
||||
|
// checks. In the asm version, we code it once instead of once per switch case. |
||||
|
ADD R4, R6, R6 |
||||
|
SUB $58, R6, R6 |
||||
|
MOVD R6, R3 |
||||
|
SUB R11, R3, R3 |
||||
|
CMP R12, R3 |
||||
|
BGT errCorrupt |
||||
|
|
||||
|
// case x == 60: |
||||
|
MOVW $61, R1 |
||||
|
CMPW R1, R4 |
||||
|
BEQ tagLit61 |
||||
|
BGT tagLit62Plus |
||||
|
|
||||
|
// x = uint32(src[s-1]) |
||||
|
MOVBU -1(R6), R4 |
||||
|
B doLit |
||||
|
|
||||
|
tagLit61: |
||||
|
// case x == 61: |
||||
|
// x = uint32(src[s-2]) | uint32(src[s-1])<<8 |
||||
|
MOVHU -2(R6), R4 |
||||
|
B doLit |
||||
|
|
||||
|
tagLit62Plus: |
||||
|
CMPW $62, R4 |
||||
|
BHI tagLit63 |
||||
|
|
||||
|
// case x == 62: |
||||
|
// x = uint32(src[s-3]) | uint32(src[s-2])<<8 | uint32(src[s-1])<<16 |
||||
|
MOVHU -3(R6), R4 |
||||
|
MOVBU -1(R6), R3 |
||||
|
ORR R3<<16, R4 |
||||
|
B doLit |
||||
|
|
||||
|
tagLit63: |
||||
|
// case x == 63: |
||||
|
// x = uint32(src[s-4]) | uint32(src[s-3])<<8 | uint32(src[s-2])<<16 | uint32(src[s-1])<<24 |
||||
|
MOVWU -4(R6), R4 |
||||
|
B doLit |
||||
|
|
||||
|
// The code above handles literal tags. |
||||
|
// ---------------------------------------- |
||||
|
// The code below handles copy tags. |
||||
|
|
||||
|
tagCopy4: |
||||
|
// case tagCopy4: |
||||
|
// s += 5 |
||||
|
ADD $5, R6, R6 |
||||
|
|
||||
|
// if uint(s) > uint(len(src)) { etc } |
||||
|
MOVD R6, R3 |
||||
|
SUB R11, R3, R3 |
||||
|
CMP R12, R3 |
||||
|
BGT errCorrupt |
||||
|
|
||||
|
// length = 1 + int(src[s-5])>>2 |
||||
|
MOVD $1, R1 |
||||
|
ADD R4>>2, R1, R4 |
||||
|
|
||||
|
// offset = int(uint32(src[s-4]) | uint32(src[s-3])<<8 | uint32(src[s-2])<<16 | uint32(src[s-1])<<24) |
||||
|
MOVWU -4(R6), R5 |
||||
|
B doCopy |
||||
|
|
||||
|
tagCopy2: |
||||
|
// case tagCopy2: |
||||
|
// s += 3 |
||||
|
ADD $3, R6, R6 |
||||
|
|
||||
|
// if uint(s) > uint(len(src)) { etc } |
||||
|
MOVD R6, R3 |
||||
|
SUB R11, R3, R3 |
||||
|
CMP R12, R3 |
||||
|
BGT errCorrupt |
||||
|
|
||||
|
// length = 1 + int(src[s-3])>>2 |
||||
|
MOVD $1, R1 |
||||
|
ADD R4>>2, R1, R4 |
||||
|
|
||||
|
// offset = int(uint32(src[s-2]) | uint32(src[s-1])<<8) |
||||
|
MOVHU -2(R6), R5 |
||||
|
B doCopy |
||||
|
|
||||
|
tagCopy: |
||||
|
// We have a copy tag. We assume that: |
||||
|
// - R3 == src[s] & 0x03 |
||||
|
// - R4 == src[s] |
||||
|
CMP $2, R3 |
||||
|
BEQ tagCopy2 |
||||
|
BGT tagCopy4 |
||||
|
|
||||
|
// case tagCopy1: |
||||
|
// s += 2 |
||||
|
ADD $2, R6, R6 |
||||
|
|
||||
|
// if uint(s) > uint(len(src)) { etc } |
||||
|
MOVD R6, R3 |
||||
|
SUB R11, R3, R3 |
||||
|
CMP R12, R3 |
||||
|
BGT errCorrupt |
||||
|
|
||||
|
// offset = int(uint32(src[s-2])&0xe0<<3 | uint32(src[s-1])) |
||||
|
MOVD R4, R5 |
||||
|
AND $0xe0, R5 |
||||
|
MOVBU -1(R6), R3 |
||||
|
ORR R5<<3, R3, R5 |
||||
|
|
||||
|
// length = 4 + int(src[s-2])>>2&0x7 |
||||
|
MOVD $7, R1 |
||||
|
AND R4>>2, R1, R4 |
||||
|
ADD $4, R4, R4 |
||||
|
|
||||
|
doCopy: |
||||
|
// This is the end of the outer "switch", when we have a copy tag. |
||||
|
// |
||||
|
// We assume that: |
||||
|
// - R4 == length && R4 > 0 |
||||
|
// - R5 == offset |
||||
|
|
||||
|
// if offset <= 0 { etc } |
||||
|
MOVD $0, R1 |
||||
|
CMP R1, R5 |
||||
|
BLE errCorrupt |
||||
|
|
||||
|
// if d < offset { etc } |
||||
|
MOVD R7, R3 |
||||
|
SUB R8, R3, R3 |
||||
|
CMP R5, R3 |
||||
|
BLT errCorrupt |
||||
|
|
||||
|
// if length > len(dst)-d { etc } |
||||
|
MOVD R10, R3 |
||||
|
SUB R7, R3, R3 |
||||
|
CMP R3, R4 |
||||
|
BGT errCorrupt |
||||
|
|
||||
|
// forwardCopy(dst[d:d+length], dst[d-offset:]); d += length |
||||
|
// |
||||
|
// Set: |
||||
|
// - R14 = len(dst)-d |
||||
|
// - R15 = &dst[d-offset] |
||||
|
MOVD R10, R14 |
||||
|
SUB R7, R14, R14 |
||||
|
MOVD R7, R15 |
||||
|
SUB R5, R15, R15 |
||||
|
|
||||
|
// !!! Try a faster technique for short (16 or fewer bytes) forward copies. |
||||
|
// |
||||
|
// First, try using two 8-byte load/stores, similar to the doLit technique |
||||
|
// above. Even if dst[d:d+length] and dst[d-offset:] can overlap, this is |
||||
|
// still OK if offset >= 8. Note that this has to be two 8-byte load/stores |
||||
|
// and not one 16-byte load/store, and the first store has to be before the |
||||
|
// second load, due to the overlap if offset is in the range [8, 16). |
||||
|
// |
||||
|
// if length > 16 || offset < 8 || len(dst)-d < 16 { |
||||
|
// goto slowForwardCopy |
||||
|
// } |
||||
|
// copy 16 bytes |
||||
|
// d += length |
||||
|
CMP $16, R4 |
||||
|
BGT slowForwardCopy |
||||
|
CMP $8, R5 |
||||
|
BLT slowForwardCopy |
||||
|
CMP $16, R14 |
||||
|
BLT slowForwardCopy |
||||
|
MOVD 0(R15), R2 |
||||
|
MOVD R2, 0(R7) |
||||
|
MOVD 8(R15), R3 |
||||
|
MOVD R3, 8(R7) |
||||
|
ADD R4, R7, R7 |
||||
|
B loop |
||||
|
|
||||
|
slowForwardCopy: |
||||
|
// !!! If the forward copy is longer than 16 bytes, or if offset < 8, we |
||||
|
// can still try 8-byte load stores, provided we can overrun up to 10 extra |
||||
|
// bytes. As above, the overrun will be fixed up by subsequent iterations |
||||
|
// of the outermost loop. |
||||
|
// |
||||
|
// The C++ snappy code calls this technique IncrementalCopyFastPath. Its |
||||
|
// commentary says: |
||||
|
// |
||||
|
// ---- |
||||
|
// |
||||
|
// The main part of this loop is a simple copy of eight bytes at a time |
||||
|
// until we've copied (at least) the requested amount of bytes. However, |
||||
|
// if d and d-offset are less than eight bytes apart (indicating a |
||||
|
// repeating pattern of length < 8), we first need to expand the pattern in |
||||
|
// order to get the correct results. For instance, if the buffer looks like |
||||
|
// this, with the eight-byte <d-offset> and <d> patterns marked as |
||||
|
// intervals: |
||||
|
// |
||||
|
// abxxxxxxxxxxxx |
||||
|
// [------] d-offset |
||||
|
// [------] d |
||||
|
// |
||||
|
// a single eight-byte copy from <d-offset> to <d> will repeat the pattern |
||||
|
// once, after which we can move <d> two bytes without moving <d-offset>: |
||||
|
// |
||||
|
// ababxxxxxxxxxx |
||||
|
// [------] d-offset |
||||
|
// [------] d |
||||
|
// |
||||
|
// and repeat the exercise until the two no longer overlap. |
||||
|
// |
||||
|
// This allows us to do very well in the special case of one single byte |
||||
|
// repeated many times, without taking a big hit for more general cases. |
||||
|
// |
||||
|
// The worst case of extra writing past the end of the match occurs when |
||||
|
// offset == 1 and length == 1; the last copy will read from byte positions |
||||
|
// [0..7] and write to [4..11], whereas it was only supposed to write to |
||||
|
// position 1. Thus, ten excess bytes. |
||||
|
// |
||||
|
// ---- |
||||
|
// |
||||
|
// That "10 byte overrun" worst case is confirmed by Go's |
||||
|
// TestSlowForwardCopyOverrun, which also tests the fixUpSlowForwardCopy |
||||
|
// and finishSlowForwardCopy algorithm. |
||||
|
// |
||||
|
// if length > len(dst)-d-10 { |
||||
|
// goto verySlowForwardCopy |
||||
|
// } |
||||
|
SUB $10, R14, R14 |
||||
|
CMP R14, R4 |
||||
|
BGT verySlowForwardCopy |
||||
|
|
||||
|
makeOffsetAtLeast8: |
||||
|
// !!! As above, expand the pattern so that offset >= 8 and we can use |
||||
|
// 8-byte load/stores. |
||||
|
// |
||||
|
// for offset < 8 { |
||||
|
// copy 8 bytes from dst[d-offset:] to dst[d:] |
||||
|
// length -= offset |
||||
|
// d += offset |
||||
|
// offset += offset |
||||
|
// // The two previous lines together means that d-offset, and therefore |
||||
|
// // R15, is unchanged. |
||||
|
// } |
||||
|
CMP $8, R5 |
||||
|
BGE fixUpSlowForwardCopy |
||||
|
MOVD (R15), R3 |
||||
|
MOVD R3, (R7) |
||||
|
SUB R5, R4, R4 |
||||
|
ADD R5, R7, R7 |
||||
|
ADD R5, R5, R5 |
||||
|
B makeOffsetAtLeast8 |
||||
|
|
||||
|
fixUpSlowForwardCopy: |
||||
|
// !!! Add length (which might be negative now) to d (implied by R7 being |
||||
|
// &dst[d]) so that d ends up at the right place when we jump back to the |
||||
|
// top of the loop. Before we do that, though, we save R7 to R2 so that, if |
||||
|
// length is positive, copying the remaining length bytes will write to the |
||||
|
// right place. |
||||
|
MOVD R7, R2 |
||||
|
ADD R4, R7, R7 |
||||
|
|
||||
|
finishSlowForwardCopy: |
||||
|
// !!! Repeat 8-byte load/stores until length <= 0. Ending with a negative |
||||
|
// length means that we overrun, but as above, that will be fixed up by |
||||
|
// subsequent iterations of the outermost loop. |
||||
|
MOVD $0, R1 |
||||
|
CMP R1, R4 |
||||
|
BLE loop |
||||
|
MOVD (R15), R3 |
||||
|
MOVD R3, (R2) |
||||
|
ADD $8, R15, R15 |
||||
|
ADD $8, R2, R2 |
||||
|
SUB $8, R4, R4 |
||||
|
B finishSlowForwardCopy |
||||
|
|
||||
|
verySlowForwardCopy: |
||||
|
// verySlowForwardCopy is a simple implementation of forward copy. In C |
||||
|
// parlance, this is a do/while loop instead of a while loop, since we know |
||||
|
// that length > 0. In Go syntax: |
||||
|
// |
||||
|
// for { |
||||
|
// dst[d] = dst[d - offset] |
||||
|
// d++ |
||||
|
// length-- |
||||
|
// if length == 0 { |
||||
|
// break |
||||
|
// } |
||||
|
// } |
||||
|
MOVB (R15), R3 |
||||
|
MOVB R3, (R7) |
||||
|
ADD $1, R15, R15 |
||||
|
ADD $1, R7, R7 |
||||
|
SUB $1, R4, R4 |
||||
|
CBNZ R4, verySlowForwardCopy |
||||
|
B loop |
||||
|
|
||||
|
// The code above handles copy tags. |
||||
|
// ---------------------------------------- |
||||
|
|
||||
|
end: |
||||
|
// This is the end of the "for s < len(src)". |
||||
|
// |
||||
|
// if d != len(dst) { etc } |
||||
|
CMP R10, R7 |
||||
|
BNE errCorrupt |
||||
|
|
||||
|
// return 0 |
||||
|
MOVD $0, ret+48(FP) |
||||
|
RET |
||||
|
|
||||
|
errCorrupt: |
||||
|
// return decodeErrCodeCorrupt |
||||
|
MOVD $1, R2 |
||||
|
MOVD R2, ret+48(FP) |
||||
|
RET |
||||
@ -0,0 +1,722 @@ |
|||||
|
// Copyright 2020 The Go Authors. All rights reserved. |
||||
|
// Use of this source code is governed by a BSD-style |
||||
|
// license that can be found in the LICENSE file. |
||||
|
|
||||
|
// +build !appengine |
||||
|
// +build gc |
||||
|
// +build !noasm |
||||
|
|
||||
|
#include "textflag.h" |
||||
|
|
||||
|
// The asm code generally follows the pure Go code in encode_other.go, except |
||||
|
// where marked with a "!!!". |
||||
|
|
||||
|
// ---------------------------------------------------------------------------- |
||||
|
|
||||
|
// func emitLiteral(dst, lit []byte) int |
||||
|
// |
||||
|
// All local variables fit into registers. The register allocation: |
||||
|
// - R3 len(lit) |
||||
|
// - R4 n |
||||
|
// - R6 return value |
||||
|
// - R8 &dst[i] |
||||
|
// - R10 &lit[0] |
||||
|
// |
||||
|
// The 32 bytes of stack space is to call runtime·memmove. |
||||
|
// |
||||
|
// The unusual register allocation of local variables, such as R10 for the |
||||
|
// source pointer, matches the allocation used at the call site in encodeBlock, |
||||
|
// which makes it easier to manually inline this function. |
||||
|
TEXT ·emitLiteral(SB), NOSPLIT, $32-56 |
||||
|
MOVD dst_base+0(FP), R8 |
||||
|
MOVD lit_base+24(FP), R10 |
||||
|
MOVD lit_len+32(FP), R3 |
||||
|
MOVD R3, R6 |
||||
|
MOVW R3, R4 |
||||
|
SUBW $1, R4, R4 |
||||
|
|
||||
|
CMPW $60, R4 |
||||
|
BLT oneByte |
||||
|
CMPW $256, R4 |
||||
|
BLT twoBytes |
||||
|
|
||||
|
threeBytes: |
||||
|
MOVD $0xf4, R2 |
||||
|
MOVB R2, 0(R8) |
||||
|
MOVW R4, 1(R8) |
||||
|
ADD $3, R8, R8 |
||||
|
ADD $3, R6, R6 |
||||
|
B memmove |
||||
|
|
||||
|
twoBytes: |
||||
|
MOVD $0xf0, R2 |
||||
|
MOVB R2, 0(R8) |
||||
|
MOVB R4, 1(R8) |
||||
|
ADD $2, R8, R8 |
||||
|
ADD $2, R6, R6 |
||||
|
B memmove |
||||
|
|
||||
|
oneByte: |
||||
|
LSLW $2, R4, R4 |
||||
|
MOVB R4, 0(R8) |
||||
|
ADD $1, R8, R8 |
||||
|
ADD $1, R6, R6 |
||||
|
|
||||
|
memmove: |
||||
|
MOVD R6, ret+48(FP) |
||||
|
|
||||
|
// copy(dst[i:], lit) |
||||
|
// |
||||
|
// This means calling runtime·memmove(&dst[i], &lit[0], len(lit)), so we push |
||||
|
// R8, R10 and R3 as arguments. |
||||
|
MOVD R8, 8(RSP) |
||||
|
MOVD R10, 16(RSP) |
||||
|
MOVD R3, 24(RSP) |
||||
|
CALL runtime·memmove(SB) |
||||
|
RET |
||||
|
|
||||
|
// ---------------------------------------------------------------------------- |
||||
|
|
||||
|
// func emitCopy(dst []byte, offset, length int) int |
||||
|
// |
||||
|
// All local variables fit into registers. The register allocation: |
||||
|
// - R3 length |
||||
|
// - R7 &dst[0] |
||||
|
// - R8 &dst[i] |
||||
|
// - R11 offset |
||||
|
// |
||||
|
// The unusual register allocation of local variables, such as R11 for the |
||||
|
// offset, matches the allocation used at the call site in encodeBlock, which |
||||
|
// makes it easier to manually inline this function. |
||||
|
TEXT ·emitCopy(SB), NOSPLIT, $0-48 |
||||
|
MOVD dst_base+0(FP), R8 |
||||
|
MOVD R8, R7 |
||||
|
MOVD offset+24(FP), R11 |
||||
|
MOVD length+32(FP), R3 |
||||
|
|
||||
|
loop0: |
||||
|
// for length >= 68 { etc } |
||||
|
CMPW $68, R3 |
||||
|
BLT step1 |
||||
|
|
||||
|
// Emit a length 64 copy, encoded as 3 bytes. |
||||
|
MOVD $0xfe, R2 |
||||
|
MOVB R2, 0(R8) |
||||
|
MOVW R11, 1(R8) |
||||
|
ADD $3, R8, R8 |
||||
|
SUB $64, R3, R3 |
||||
|
B loop0 |
||||
|
|
||||
|
step1: |
||||
|
// if length > 64 { etc } |
||||
|
CMP $64, R3 |
||||
|
BLE step2 |
||||
|
|
||||
|
// Emit a length 60 copy, encoded as 3 bytes. |
||||
|
MOVD $0xee, R2 |
||||
|
MOVB R2, 0(R8) |
||||
|
MOVW R11, 1(R8) |
||||
|
ADD $3, R8, R8 |
||||
|
SUB $60, R3, R3 |
||||
|
|
||||
|
step2: |
||||
|
// if length >= 12 || offset >= 2048 { goto step3 } |
||||
|
CMP $12, R3 |
||||
|
BGE step3 |
||||
|
CMPW $2048, R11 |
||||
|
BGE step3 |
||||
|
|
||||
|
// Emit the remaining copy, encoded as 2 bytes. |
||||
|
MOVB R11, 1(R8) |
||||
|
LSRW $3, R11, R11 |
||||
|
AND $0xe0, R11, R11 |
||||
|
SUB $4, R3, R3 |
||||
|
LSLW $2, R3 |
||||
|
AND $0xff, R3, R3 |
||||
|
ORRW R3, R11, R11 |
||||
|
ORRW $1, R11, R11 |
||||
|
MOVB R11, 0(R8) |
||||
|
ADD $2, R8, R8 |
||||
|
|
||||
|
// Return the number of bytes written. |
||||
|
SUB R7, R8, R8 |
||||
|
MOVD R8, ret+40(FP) |
||||
|
RET |
||||
|
|
||||
|
step3: |
||||
|
// Emit the remaining copy, encoded as 3 bytes. |
||||
|
SUB $1, R3, R3 |
||||
|
AND $0xff, R3, R3 |
||||
|
LSLW $2, R3, R3 |
||||
|
ORRW $2, R3, R3 |
||||
|
MOVB R3, 0(R8) |
||||
|
MOVW R11, 1(R8) |
||||
|
ADD $3, R8, R8 |
||||
|
|
||||
|
// Return the number of bytes written. |
||||
|
SUB R7, R8, R8 |
||||
|
MOVD R8, ret+40(FP) |
||||
|
RET |
||||
|
|
||||
|
// ---------------------------------------------------------------------------- |
||||
|
|
||||
|
// func extendMatch(src []byte, i, j int) int |
||||
|
// |
||||
|
// All local variables fit into registers. The register allocation: |
||||
|
// - R6 &src[0] |
||||
|
// - R7 &src[j] |
||||
|
// - R13 &src[len(src) - 8] |
||||
|
// - R14 &src[len(src)] |
||||
|
// - R15 &src[i] |
||||
|
// |
||||
|
// The unusual register allocation of local variables, such as R15 for a source |
||||
|
// pointer, matches the allocation used at the call site in encodeBlock, which |
||||
|
// makes it easier to manually inline this function. |
||||
|
TEXT ·extendMatch(SB), NOSPLIT, $0-48 |
||||
|
MOVD src_base+0(FP), R6 |
||||
|
MOVD src_len+8(FP), R14 |
||||
|
MOVD i+24(FP), R15 |
||||
|
MOVD j+32(FP), R7 |
||||
|
ADD R6, R14, R14 |
||||
|
ADD R6, R15, R15 |
||||
|
ADD R6, R7, R7 |
||||
|
MOVD R14, R13 |
||||
|
SUB $8, R13, R13 |
||||
|
|
||||
|
cmp8: |
||||
|
// As long as we are 8 or more bytes before the end of src, we can load and |
||||
|
// compare 8 bytes at a time. If those 8 bytes are equal, repeat. |
||||
|
CMP R13, R7 |
||||
|
BHI cmp1 |
||||
|
MOVD (R15), R3 |
||||
|
MOVD (R7), R4 |
||||
|
CMP R4, R3 |
||||
|
BNE bsf |
||||
|
ADD $8, R15, R15 |
||||
|
ADD $8, R7, R7 |
||||
|
B cmp8 |
||||
|
|
||||
|
bsf: |
||||
|
// If those 8 bytes were not equal, XOR the two 8 byte values, and return |
||||
|
// the index of the first byte that differs. |
||||
|
// RBIT reverses the bit order, then CLZ counts the leading zeros, the |
||||
|
// combination of which finds the least significant bit which is set. |
||||
|
// The arm64 architecture is little-endian, and the shift by 3 converts |
||||
|
// a bit index to a byte index. |
||||
|
EOR R3, R4, R4 |
||||
|
RBIT R4, R4 |
||||
|
CLZ R4, R4 |
||||
|
ADD R4>>3, R7, R7 |
||||
|
|
||||
|
// Convert from &src[ret] to ret. |
||||
|
SUB R6, R7, R7 |
||||
|
MOVD R7, ret+40(FP) |
||||
|
RET |
||||
|
|
||||
|
cmp1: |
||||
|
// In src's tail, compare 1 byte at a time. |
||||
|
CMP R7, R14 |
||||
|
BLS extendMatchEnd |
||||
|
MOVB (R15), R3 |
||||
|
MOVB (R7), R4 |
||||
|
CMP R4, R3 |
||||
|
BNE extendMatchEnd |
||||
|
ADD $1, R15, R15 |
||||
|
ADD $1, R7, R7 |
||||
|
B cmp1 |
||||
|
|
||||
|
extendMatchEnd: |
||||
|
// Convert from &src[ret] to ret. |
||||
|
SUB R6, R7, R7 |
||||
|
MOVD R7, ret+40(FP) |
||||
|
RET |
||||
|
|
||||
|
// ---------------------------------------------------------------------------- |
||||
|
|
||||
|
// func encodeBlock(dst, src []byte) (d int) |
||||
|
// |
||||
|
// All local variables fit into registers, other than "var table". The register |
||||
|
// allocation: |
||||
|
// - R3 . . |
||||
|
// - R4 . . |
||||
|
// - R5 64 shift |
||||
|
// - R6 72 &src[0], tableSize |
||||
|
// - R7 80 &src[s] |
||||
|
// - R8 88 &dst[d] |
||||
|
// - R9 96 sLimit |
||||
|
// - R10 . &src[nextEmit] |
||||
|
// - R11 104 prevHash, currHash, nextHash, offset |
||||
|
// - R12 112 &src[base], skip |
||||
|
// - R13 . &src[nextS], &src[len(src) - 8] |
||||
|
// - R14 . len(src), bytesBetweenHashLookups, &src[len(src)], x |
||||
|
// - R15 120 candidate |
||||
|
// - R16 . hash constant, 0x1e35a7bd |
||||
|
// - R17 . &table |
||||
|
// - . 128 table |
||||
|
// |
||||
|
// The second column (64, 72, etc) is the stack offset to spill the registers |
||||
|
// when calling other functions. We could pack this slightly tighter, but it's |
||||
|
// simpler to have a dedicated spill map independent of the function called. |
||||
|
// |
||||
|
// "var table [maxTableSize]uint16" takes up 32768 bytes of stack space. An |
||||
|
// extra 64 bytes, to call other functions, and an extra 64 bytes, to spill |
||||
|
// local variables (registers) during calls gives 32768 + 64 + 64 = 32896. |
||||
|
TEXT ·encodeBlock(SB), 0, $32896-56 |
||||
|
MOVD dst_base+0(FP), R8 |
||||
|
MOVD src_base+24(FP), R7 |
||||
|
MOVD src_len+32(FP), R14 |
||||
|
|
||||
|
// shift, tableSize := uint32(32-8), 1<<8 |
||||
|
MOVD $24, R5 |
||||
|
MOVD $256, R6 |
||||
|
MOVW $0xa7bd, R16 |
||||
|
MOVKW $(0x1e35<<16), R16 |
||||
|
|
||||
|
calcShift: |
||||
|
// for ; tableSize < maxTableSize && tableSize < len(src); tableSize *= 2 { |
||||
|
// shift-- |
||||
|
// } |
||||
|
MOVD $16384, R2 |
||||
|
CMP R2, R6 |
||||
|
BGE varTable |
||||
|
CMP R14, R6 |
||||
|
BGE varTable |
||||
|
SUB $1, R5, R5 |
||||
|
LSL $1, R6, R6 |
||||
|
B calcShift |
||||
|
|
||||
|
varTable: |
||||
|
// var table [maxTableSize]uint16 |
||||
|
// |
||||
|
// In the asm code, unlike the Go code, we can zero-initialize only the |
||||
|
// first tableSize elements. Each uint16 element is 2 bytes and each |
||||
|
// iterations writes 64 bytes, so we can do only tableSize/32 writes |
||||
|
// instead of the 2048 writes that would zero-initialize all of table's |
||||
|
// 32768 bytes. This clear could overrun the first tableSize elements, but |
||||
|
// it won't overrun the allocated stack size. |
||||
|
ADD $128, RSP, R17 |
||||
|
MOVD R17, R4 |
||||
|
|
||||
|
// !!! R6 = &src[tableSize] |
||||
|
ADD R6<<1, R17, R6 |
||||
|
|
||||
|
memclr: |
||||
|
STP.P (ZR, ZR), 64(R4) |
||||
|
STP (ZR, ZR), -48(R4) |
||||
|
STP (ZR, ZR), -32(R4) |
||||
|
STP (ZR, ZR), -16(R4) |
||||
|
CMP R4, R6 |
||||
|
BHI memclr |
||||
|
|
||||
|
// !!! R6 = &src[0] |
||||
|
MOVD R7, R6 |
||||
|
|
||||
|
// sLimit := len(src) - inputMargin |
||||
|
MOVD R14, R9 |
||||
|
SUB $15, R9, R9 |
||||
|
|
||||
|
// !!! Pre-emptively spill R5, R6 and R9 to the stack. Their values don't |
||||
|
// change for the rest of the function. |
||||
|
MOVD R5, 64(RSP) |
||||
|
MOVD R6, 72(RSP) |
||||
|
MOVD R9, 96(RSP) |
||||
|
|
||||
|
// nextEmit := 0 |
||||
|
MOVD R6, R10 |
||||
|
|
||||
|
// s := 1 |
||||
|
ADD $1, R7, R7 |
||||
|
|
||||
|
// nextHash := hash(load32(src, s), shift) |
||||
|
MOVW 0(R7), R11 |
||||
|
MULW R16, R11, R11 |
||||
|
LSRW R5, R11, R11 |
||||
|
|
||||
|
outer: |
||||
|
// for { etc } |
||||
|
|
||||
|
// skip := 32 |
||||
|
MOVD $32, R12 |
||||
|
|
||||
|
// nextS := s |
||||
|
MOVD R7, R13 |
||||
|
|
||||
|
// candidate := 0 |
||||
|
MOVD $0, R15 |
||||
|
|
||||
|
inner0: |
||||
|
// for { etc } |
||||
|
|
||||
|
// s := nextS |
||||
|
MOVD R13, R7 |
||||
|
|
||||
|
// bytesBetweenHashLookups := skip >> 5 |
||||
|
MOVD R12, R14 |
||||
|
LSR $5, R14, R14 |
||||
|
|
||||
|
// nextS = s + bytesBetweenHashLookups |
||||
|
ADD R14, R13, R13 |
||||
|
|
||||
|
// skip += bytesBetweenHashLookups |
||||
|
ADD R14, R12, R12 |
||||
|
|
||||
|
// if nextS > sLimit { goto emitRemainder } |
||||
|
MOVD R13, R3 |
||||
|
SUB R6, R3, R3 |
||||
|
CMP R9, R3 |
||||
|
BHI emitRemainder |
||||
|
|
||||
|
// candidate = int(table[nextHash]) |
||||
|
MOVHU 0(R17)(R11<<1), R15 |
||||
|
|
||||
|
// table[nextHash] = uint16(s) |
||||
|
MOVD R7, R3 |
||||
|
SUB R6, R3, R3 |
||||
|
|
||||
|
MOVH R3, 0(R17)(R11<<1) |
||||
|
|
||||
|
// nextHash = hash(load32(src, nextS), shift) |
||||
|
MOVW 0(R13), R11 |
||||
|
MULW R16, R11 |
||||
|
LSRW R5, R11, R11 |
||||
|
|
||||
|
// if load32(src, s) != load32(src, candidate) { continue } break |
||||
|
MOVW 0(R7), R3 |
||||
|
MOVW (R6)(R15), R4 |
||||
|
CMPW R4, R3 |
||||
|
BNE inner0 |
||||
|
|
||||
|
fourByteMatch: |
||||
|
// As per the encode_other.go code: |
||||
|
// |
||||
|
// A 4-byte match has been found. We'll later see etc. |
||||
|
|
||||
|
// !!! Jump to a fast path for short (<= 16 byte) literals. See the comment |
||||
|
// on inputMargin in encode.go. |
||||
|
MOVD R7, R3 |
||||
|
SUB R10, R3, R3 |
||||
|
CMP $16, R3 |
||||
|
BLE emitLiteralFastPath |
||||
|
|
||||
|
// ---------------------------------------- |
||||
|
// Begin inline of the emitLiteral call. |
||||
|
// |
||||
|
// d += emitLiteral(dst[d:], src[nextEmit:s]) |
||||
|
|
||||
|
MOVW R3, R4 |
||||
|
SUBW $1, R4, R4 |
||||
|
|
||||
|
MOVW $60, R2 |
||||
|
CMPW R2, R4 |
||||
|
BLT inlineEmitLiteralOneByte |
||||
|
MOVW $256, R2 |
||||
|
CMPW R2, R4 |
||||
|
BLT inlineEmitLiteralTwoBytes |
||||
|
|
||||
|
inlineEmitLiteralThreeBytes: |
||||
|
MOVD $0xf4, R1 |
||||
|
MOVB R1, 0(R8) |
||||
|
MOVW R4, 1(R8) |
||||
|
ADD $3, R8, R8 |
||||
|
B inlineEmitLiteralMemmove |
||||
|
|
||||
|
inlineEmitLiteralTwoBytes: |
||||
|
MOVD $0xf0, R1 |
||||
|
MOVB R1, 0(R8) |
||||
|
MOVB R4, 1(R8) |
||||
|
ADD $2, R8, R8 |
||||
|
B inlineEmitLiteralMemmove |
||||
|
|
||||
|
inlineEmitLiteralOneByte: |
||||
|
LSLW $2, R4, R4 |
||||
|
MOVB R4, 0(R8) |
||||
|
ADD $1, R8, R8 |
||||
|
|
||||
|
inlineEmitLiteralMemmove: |
||||
|
// Spill local variables (registers) onto the stack; call; unspill. |
||||
|
// |
||||
|
// copy(dst[i:], lit) |
||||
|
// |
||||
|
// This means calling runtime·memmove(&dst[i], &lit[0], len(lit)), so we push |
||||
|
// R8, R10 and R3 as arguments. |
||||
|
MOVD R8, 8(RSP) |
||||
|
MOVD R10, 16(RSP) |
||||
|
MOVD R3, 24(RSP) |
||||
|
|
||||
|
// Finish the "d +=" part of "d += emitLiteral(etc)". |
||||
|
ADD R3, R8, R8 |
||||
|
MOVD R7, 80(RSP) |
||||
|
MOVD R8, 88(RSP) |
||||
|
MOVD R15, 120(RSP) |
||||
|
CALL runtime·memmove(SB) |
||||
|
MOVD 64(RSP), R5 |
||||
|
MOVD 72(RSP), R6 |
||||
|
MOVD 80(RSP), R7 |
||||
|
MOVD 88(RSP), R8 |
||||
|
MOVD 96(RSP), R9 |
||||
|
MOVD 120(RSP), R15 |
||||
|
ADD $128, RSP, R17 |
||||
|
MOVW $0xa7bd, R16 |
||||
|
MOVKW $(0x1e35<<16), R16 |
||||
|
B inner1 |
||||
|
|
||||
|
inlineEmitLiteralEnd: |
||||
|
// End inline of the emitLiteral call. |
||||
|
// ---------------------------------------- |
||||
|
|
||||
|
emitLiteralFastPath: |
||||
|
// !!! Emit the 1-byte encoding "uint8(len(lit)-1)<<2". |
||||
|
MOVB R3, R4 |
||||
|
SUBW $1, R4, R4 |
||||
|
AND $0xff, R4, R4 |
||||
|
LSLW $2, R4, R4 |
||||
|
MOVB R4, (R8) |
||||
|
ADD $1, R8, R8 |
||||
|
|
||||
|
// !!! Implement the copy from lit to dst as a 16-byte load and store. |
||||
|
// (Encode's documentation says that dst and src must not overlap.) |
||||
|
// |
||||
|
// This always copies 16 bytes, instead of only len(lit) bytes, but that's |
||||
|
// OK. Subsequent iterations will fix up the overrun. |
||||
|
// |
||||
|
// Note that on arm64, it is legal and cheap to issue unaligned 8-byte or |
||||
|
// 16-byte loads and stores. This technique probably wouldn't be as |
||||
|
// effective on architectures that are fussier about alignment. |
||||
|
LDP 0(R10), (R0, R1) |
||||
|
STP (R0, R1), 0(R8) |
||||
|
ADD R3, R8, R8 |
||||
|
|
||||
|
inner1: |
||||
|
// for { etc } |
||||
|
|
||||
|
// base := s |
||||
|
MOVD R7, R12 |
||||
|
|
||||
|
// !!! offset := base - candidate |
||||
|
MOVD R12, R11 |
||||
|
SUB R15, R11, R11 |
||||
|
SUB R6, R11, R11 |
||||
|
|
||||
|
// ---------------------------------------- |
||||
|
// Begin inline of the extendMatch call. |
||||
|
// |
||||
|
// s = extendMatch(src, candidate+4, s+4) |
||||
|
|
||||
|
// !!! R14 = &src[len(src)] |
||||
|
MOVD src_len+32(FP), R14 |
||||
|
ADD R6, R14, R14 |
||||
|
|
||||
|
// !!! R13 = &src[len(src) - 8] |
||||
|
MOVD R14, R13 |
||||
|
SUB $8, R13, R13 |
||||
|
|
||||
|
// !!! R15 = &src[candidate + 4] |
||||
|
ADD $4, R15, R15 |
||||
|
ADD R6, R15, R15 |
||||
|
|
||||
|
// !!! s += 4 |
||||
|
ADD $4, R7, R7 |
||||
|
|
||||
|
inlineExtendMatchCmp8: |
||||
|
// As long as we are 8 or more bytes before the end of src, we can load and |
||||
|
// compare 8 bytes at a time. If those 8 bytes are equal, repeat. |
||||
|
CMP R13, R7 |
||||
|
BHI inlineExtendMatchCmp1 |
||||
|
MOVD (R15), R3 |
||||
|
MOVD (R7), R4 |
||||
|
CMP R4, R3 |
||||
|
BNE inlineExtendMatchBSF |
||||
|
ADD $8, R15, R15 |
||||
|
ADD $8, R7, R7 |
||||
|
B inlineExtendMatchCmp8 |
||||
|
|
||||
|
inlineExtendMatchBSF: |
||||
|
// If those 8 bytes were not equal, XOR the two 8 byte values, and return |
||||
|
// the index of the first byte that differs. |
||||
|
// RBIT reverses the bit order, then CLZ counts the leading zeros, the |
||||
|
// combination of which finds the least significant bit which is set. |
||||
|
// The arm64 architecture is little-endian, and the shift by 3 converts |
||||
|
// a bit index to a byte index. |
||||
|
EOR R3, R4, R4 |
||||
|
RBIT R4, R4 |
||||
|
CLZ R4, R4 |
||||
|
ADD R4>>3, R7, R7 |
||||
|
B inlineExtendMatchEnd |
||||
|
|
||||
|
inlineExtendMatchCmp1: |
||||
|
// In src's tail, compare 1 byte at a time. |
||||
|
CMP R7, R14 |
||||
|
BLS inlineExtendMatchEnd |
||||
|
MOVB (R15), R3 |
||||
|
MOVB (R7), R4 |
||||
|
CMP R4, R3 |
||||
|
BNE inlineExtendMatchEnd |
||||
|
ADD $1, R15, R15 |
||||
|
ADD $1, R7, R7 |
||||
|
B inlineExtendMatchCmp1 |
||||
|
|
||||
|
inlineExtendMatchEnd: |
||||
|
// End inline of the extendMatch call. |
||||
|
// ---------------------------------------- |
||||
|
|
||||
|
// ---------------------------------------- |
||||
|
// Begin inline of the emitCopy call. |
||||
|
// |
||||
|
// d += emitCopy(dst[d:], base-candidate, s-base) |
||||
|
|
||||
|
// !!! length := s - base |
||||
|
MOVD R7, R3 |
||||
|
SUB R12, R3, R3 |
||||
|
|
||||
|
inlineEmitCopyLoop0: |
||||
|
// for length >= 68 { etc } |
||||
|
MOVW $68, R2 |
||||
|
CMPW R2, R3 |
||||
|
BLT inlineEmitCopyStep1 |
||||
|
|
||||
|
// Emit a length 64 copy, encoded as 3 bytes. |
||||
|
MOVD $0xfe, R1 |
||||
|
MOVB R1, 0(R8) |
||||
|
MOVW R11, 1(R8) |
||||
|
ADD $3, R8, R8 |
||||
|
SUBW $64, R3, R3 |
||||
|
B inlineEmitCopyLoop0 |
||||
|
|
||||
|
inlineEmitCopyStep1: |
||||
|
// if length > 64 { etc } |
||||
|
MOVW $64, R2 |
||||
|
CMPW R2, R3 |
||||
|
BLE inlineEmitCopyStep2 |
||||
|
|
||||
|
// Emit a length 60 copy, encoded as 3 bytes. |
||||
|
MOVD $0xee, R1 |
||||
|
MOVB R1, 0(R8) |
||||
|
MOVW R11, 1(R8) |
||||
|
ADD $3, R8, R8 |
||||
|
SUBW $60, R3, R3 |
||||
|
|
||||
|
inlineEmitCopyStep2: |
||||
|
// if length >= 12 || offset >= 2048 { goto inlineEmitCopyStep3 } |
||||
|
MOVW $12, R2 |
||||
|
CMPW R2, R3 |
||||
|
BGE inlineEmitCopyStep3 |
||||
|
MOVW $2048, R2 |
||||
|
CMPW R2, R11 |
||||
|
BGE inlineEmitCopyStep3 |
||||
|
|
||||
|
// Emit the remaining copy, encoded as 2 bytes. |
||||
|
MOVB R11, 1(R8) |
||||
|
LSRW $8, R11, R11 |
||||
|
LSLW $5, R11, R11 |
||||
|
SUBW $4, R3, R3 |
||||
|
AND $0xff, R3, R3 |
||||
|
LSLW $2, R3, R3 |
||||
|
ORRW R3, R11, R11 |
||||
|
ORRW $1, R11, R11 |
||||
|
MOVB R11, 0(R8) |
||||
|
ADD $2, R8, R8 |
||||
|
B inlineEmitCopyEnd |
||||
|
|
||||
|
inlineEmitCopyStep3: |
||||
|
// Emit the remaining copy, encoded as 3 bytes. |
||||
|
SUBW $1, R3, R3 |
||||
|
LSLW $2, R3, R3 |
||||
|
ORRW $2, R3, R3 |
||||
|
MOVB R3, 0(R8) |
||||
|
MOVW R11, 1(R8) |
||||
|
ADD $3, R8, R8 |
||||
|
|
||||
|
inlineEmitCopyEnd: |
||||
|
// End inline of the emitCopy call. |
||||
|
// ---------------------------------------- |
||||
|
|
||||
|
// nextEmit = s |
||||
|
MOVD R7, R10 |
||||
|
|
||||
|
// if s >= sLimit { goto emitRemainder } |
||||
|
MOVD R7, R3 |
||||
|
SUB R6, R3, R3 |
||||
|
CMP R3, R9 |
||||
|
BLS emitRemainder |
||||
|
|
||||
|
// As per the encode_other.go code: |
||||
|
// |
||||
|
// We could immediately etc. |
||||
|
|
||||
|
// x := load64(src, s-1) |
||||
|
MOVD -1(R7), R14 |
||||
|
|
||||
|
// prevHash := hash(uint32(x>>0), shift) |
||||
|
MOVW R14, R11 |
||||
|
MULW R16, R11, R11 |
||||
|
LSRW R5, R11, R11 |
||||
|
|
||||
|
// table[prevHash] = uint16(s-1) |
||||
|
MOVD R7, R3 |
||||
|
SUB R6, R3, R3 |
||||
|
SUB $1, R3, R3 |
||||
|
|
||||
|
MOVHU R3, 0(R17)(R11<<1) |
||||
|
|
||||
|
// currHash := hash(uint32(x>>8), shift) |
||||
|
LSR $8, R14, R14 |
||||
|
MOVW R14, R11 |
||||
|
MULW R16, R11, R11 |
||||
|
LSRW R5, R11, R11 |
||||
|
|
||||
|
// candidate = int(table[currHash]) |
||||
|
MOVHU 0(R17)(R11<<1), R15 |
||||
|
|
||||
|
// table[currHash] = uint16(s) |
||||
|
ADD $1, R3, R3 |
||||
|
MOVHU R3, 0(R17)(R11<<1) |
||||
|
|
||||
|
// if uint32(x>>8) == load32(src, candidate) { continue } |
||||
|
MOVW (R6)(R15), R4 |
||||
|
CMPW R4, R14 |
||||
|
BEQ inner1 |
||||
|
|
||||
|
// nextHash = hash(uint32(x>>16), shift) |
||||
|
LSR $8, R14, R14 |
||||
|
MOVW R14, R11 |
||||
|
MULW R16, R11, R11 |
||||
|
LSRW R5, R11, R11 |
||||
|
|
||||
|
// s++ |
||||
|
ADD $1, R7, R7 |
||||
|
|
||||
|
// break out of the inner1 for loop, i.e. continue the outer loop. |
||||
|
B outer |
||||
|
|
||||
|
emitRemainder: |
||||
|
// if nextEmit < len(src) { etc } |
||||
|
MOVD src_len+32(FP), R3 |
||||
|
ADD R6, R3, R3 |
||||
|
CMP R3, R10 |
||||
|
BEQ encodeBlockEnd |
||||
|
|
||||
|
// d += emitLiteral(dst[d:], src[nextEmit:]) |
||||
|
// |
||||
|
// Push args. |
||||
|
MOVD R8, 8(RSP) |
||||
|
MOVD $0, 16(RSP) // Unnecessary, as the callee ignores it, but conservative. |
||||
|
MOVD $0, 24(RSP) // Unnecessary, as the callee ignores it, but conservative. |
||||
|
MOVD R10, 32(RSP) |
||||
|
SUB R10, R3, R3 |
||||
|
MOVD R3, 40(RSP) |
||||
|
MOVD R3, 48(RSP) // Unnecessary, as the callee ignores it, but conservative. |
||||
|
|
||||
|
// Spill local variables (registers) onto the stack; call; unspill. |
||||
|
MOVD R8, 88(RSP) |
||||
|
CALL ·emitLiteral(SB) |
||||
|
MOVD 88(RSP), R8 |
||||
|
|
||||
|
// Finish the "d +=" part of "d += emitLiteral(etc)". |
||||
|
MOVD 56(RSP), R1 |
||||
|
ADD R1, R8, R8 |
||||
|
|
||||
|
encodeBlockEnd: |
||||
|
MOVD dst_base+0(FP), R3 |
||||
|
SUB R3, R8, R8 |
||||
|
MOVD R8, d+48(FP) |
||||
|
RET |
||||
@ -0,0 +1 @@ |
|||||
|
module github.com/golang/snappy |
||||
@ -1,15 +1,9 @@ |
|||||
# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'. |
# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'. |
||||
|
|
||||
|
|
||||
[[projects]] |
|
||||
name = "github.com/modern-go/concurrent" |
|
||||
packages = ["."] |
|
||||
revision = "e0a39a4cb4216ea8db28e22a69f4ec25610d513a" |
|
||||
version = "1.0.0" |
|
||||
|
|
||||
[solve-meta] |
[solve-meta] |
||||
analyzer-name = "dep" |
analyzer-name = "dep" |
||||
analyzer-version = 1 |
analyzer-version = 1 |
||||
inputs-digest = "daee8a88b3498b61c5640056665b8b9eea062006f5e596bbb6a3ed9119a11ec7" |
|
||||
|
input-imports = [] |
||||
solver-name = "gps-cdcl" |
solver-name = "gps-cdcl" |
||||
solver-version = 1 |
solver-version = 1 |
||||
@ -0,0 +1,3 @@ |
|||||
|
module github.com/modern-go/reflect2 |
||||
|
|
||||
|
go 1.12 |
||||
@ -0,0 +1,23 @@ |
|||||
|
//+build go1.18
|
||||
|
|
||||
|
package reflect2 |
||||
|
|
||||
|
import ( |
||||
|
"unsafe" |
||||
|
) |
||||
|
|
||||
|
// m escapes into the return value, but the caller of mapiterinit
|
||||
|
// doesn't let the return value escape.
|
||||
|
//go:noescape
|
||||
|
//go:linkname mapiterinit reflect.mapiterinit
|
||||
|
func mapiterinit(rtype unsafe.Pointer, m unsafe.Pointer, it *hiter) |
||||
|
|
||||
|
func (type2 *UnsafeMapType) UnsafeIterate(obj unsafe.Pointer) MapIterator { |
||||
|
var it hiter |
||||
|
mapiterinit(type2.rtype, *(*unsafe.Pointer)(obj), &it) |
||||
|
return &UnsafeMapIterator{ |
||||
|
hiter: &it, |
||||
|
pKeyRType: type2.pKeyRType, |
||||
|
pElemRType: type2.pElemRType, |
||||
|
} |
||||
|
} |
||||
@ -1,8 +0,0 @@ |
|||||
//+build go1.7
|
|
||||
|
|
||||
package reflect2 |
|
||||
|
|
||||
import "unsafe" |
|
||||
|
|
||||
//go:linkname resolveTypeOff reflect.resolveTypeOff
|
|
||||
func resolveTypeOff(rtype unsafe.Pointer, off int32) unsafe.Pointer |
|
||||
@ -0,0 +1,21 @@ |
|||||
|
//+build !go1.18
|
||||
|
|
||||
|
package reflect2 |
||||
|
|
||||
|
import ( |
||||
|
"unsafe" |
||||
|
) |
||||
|
|
||||
|
// m escapes into the return value, but the caller of mapiterinit
|
||||
|
// doesn't let the return value escape.
|
||||
|
//go:noescape
|
||||
|
//go:linkname mapiterinit reflect.mapiterinit
|
||||
|
func mapiterinit(rtype unsafe.Pointer, m unsafe.Pointer) (val *hiter) |
||||
|
|
||||
|
func (type2 *UnsafeMapType) UnsafeIterate(obj unsafe.Pointer) MapIterator { |
||||
|
return &UnsafeMapIterator{ |
||||
|
hiter: mapiterinit(type2.rtype, *(*unsafe.Pointer)(obj)), |
||||
|
pKeyRType: type2.pKeyRType, |
||||
|
pElemRType: type2.pElemRType, |
||||
|
} |
||||
|
} |
||||
@ -1,9 +0,0 @@ |
|||||
//+build !go1.7
|
|
||||
|
|
||||
package reflect2 |
|
||||
|
|
||||
import "unsafe" |
|
||||
|
|
||||
func resolveTypeOff(rtype unsafe.Pointer, off int32) unsafe.Pointer { |
|
||||
return nil |
|
||||
} |
|
||||
@ -1,14 +0,0 @@ |
|||||
//+build !go1.9
|
|
||||
|
|
||||
package reflect2 |
|
||||
|
|
||||
import ( |
|
||||
"unsafe" |
|
||||
) |
|
||||
|
|
||||
//go:linkname makemap reflect.makemap
|
|
||||
func makemap(rtype unsafe.Pointer) (m unsafe.Pointer) |
|
||||
|
|
||||
func makeMapWithSize(rtype unsafe.Pointer, cap int) unsafe.Pointer { |
|
||||
return makemap(rtype) |
|
||||
} |
|
||||
@ -1,12 +0,0 @@ |
|||||
#!/usr/bin/env bash |
|
||||
|
|
||||
set -e |
|
||||
echo "" > coverage.txt |
|
||||
|
|
||||
for d in $(go list github.com/modern-go/reflect2-tests/... | grep -v vendor); do |
|
||||
go test -coverprofile=profile.out -coverpkg=github.com/modern-go/reflect2 $d |
|
||||
if [ -f profile.out ]; then |
|
||||
cat profile.out >> coverage.txt |
|
||||
rm profile.out |
|
||||
fi |
|
||||
done |
|
||||
@ -0,0 +1,24 @@ |
|||||
|
linters: |
||||
|
enable: |
||||
|
- gosimple |
||||
|
- deadcode |
||||
|
- typecheck |
||||
|
- govet |
||||
|
- errcheck |
||||
|
- staticcheck |
||||
|
- unused |
||||
|
- structcheck |
||||
|
- varcheck |
||||
|
- dupl |
||||
|
#- gocyclo # The cyclomatic complexety of a lot of functions is too high, we should refactor those another time. |
||||
|
- gofmt |
||||
|
- misspell |
||||
|
- gocritic |
||||
|
- bidichk |
||||
|
- ineffassign |
||||
|
enable-all: false |
||||
|
disable-all: true |
||||
|
fast: false |
||||
|
|
||||
|
run: |
||||
|
timeout: 3m |
||||
1201
vendor/xorm.io/xorm/dialects/dameng.go
File diff suppressed because it is too large
View File
File diff suppressed because it is too large
View File
Some files were not shown because too many files changed in this diff
Write
Preview
Loading…
Cancel
Save
Reference in new issue