vendor/github.com/golang/snappy/encode_amd64.s - voltha-openolt-adapter - Gitiles

 // Copyright 2016 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 XXX lines assemble on Go 1.4, 1.5 and 1.7, but not 1.6, due to a
 // Go toolchain regression. See https://github.com/golang/go/issues/15426 and
 // https://github.com/golang/snappy/issues/29
 //
 // As a workaround, the package was built with a known good assembler, and
 // those instructions were disassembled by "objdump -d" to yield the
 //	4e 0f b7 7c 5c 78       movzwq 0x78(%rsp,%r11,2),%r15
 // style comments, in AT&T asm syntax. Note that rsp here is a physical
 // register, not Go/asm's SP pseudo-register (see https://golang.org/doc/asm).
 // The instructions were then encoded as "BYTE $0x.." sequences, which assemble
 // fine on Go 1.6.

 // 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:
 //	- AX	len(lit)
 //	- BX	n
 //	- DX	return value
 //	- DI	&dst[i]
 //	- R10	&lit[0]
 //
 // The 24 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, $24-56
 	MOVQ dst_base+0(FP), DI
 	MOVQ lit_base+24(FP), R10
 	MOVQ lit_len+32(FP), AX
 	MOVQ AX, DX
 	MOVL AX, BX
 	SUBL $1, BX

 	CMPL BX, $60
 	JLT  oneByte
 	CMPL BX, $256
 	JLT  twoBytes

 threeBytes:
 	MOVB $0xf4, 0(DI)
 	MOVW BX, 1(DI)
 	ADDQ $3, DI
 	ADDQ $3, DX
 	JMP  memmove

 twoBytes:
 	MOVB $0xf0, 0(DI)
 	MOVB BX, 1(DI)
 	ADDQ $2, DI
 	ADDQ $2, DX
 	JMP  memmove

 oneByte:
 	SHLB $2, BX
 	MOVB BX, 0(DI)
 	ADDQ $1, DI
 	ADDQ $1, DX

 memmove:
 	MOVQ DX, ret+48(FP)

 	// copy(dst[i:], lit)
 	//
 	// This means calling runtime·memmove(&dst[i], &lit[0], len(lit)), so we push
 	// DI, R10 and AX as arguments.
 	MOVQ DI, 0(SP)
 	MOVQ R10, 8(SP)
 	MOVQ AX, 16(SP)
 	CALL runtime·memmove(SB)
 	RET

 // ----------------------------------------------------------------------------

 // func emitCopy(dst []byte, offset, length int) int
 //
 // All local variables fit into registers. The register allocation:
 //	- AX	length
 //	- SI	&dst[0]
 //	- DI	&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
 	MOVQ dst_base+0(FP), DI
 	MOVQ DI, SI
 	MOVQ offset+24(FP), R11
 	MOVQ length+32(FP), AX

 loop0:
 	// for length >= 68 { etc }
 	CMPL AX, $68
 	JLT  step1

 	// Emit a length 64 copy, encoded as 3 bytes.
 	MOVB $0xfe, 0(DI)
 	MOVW R11, 1(DI)
 	ADDQ $3, DI
 	SUBL $64, AX
 	JMP  loop0

 step1:
 	// if length > 64 { etc }
 	CMPL AX, $64
 	JLE  step2

 	// Emit a length 60 copy, encoded as 3 bytes.
 	MOVB $0xee, 0(DI)
 	MOVW R11, 1(DI)
 	ADDQ $3, DI
 	SUBL $60, AX

 step2:
 	// if length >= 12 || offset >= 2048 { goto step3 }
 	CMPL AX, $12
 	JGE  step3
 	CMPL R11, $2048
 	JGE  step3

 	// Emit the remaining copy, encoded as 2 bytes.
 	MOVB R11, 1(DI)
 	SHRL $8, R11
 	SHLB $5, R11
 	SUBB $4, AX
 	SHLB $2, AX
 	ORB  AX, R11
 	ORB  $1, R11
 	MOVB R11, 0(DI)
 	ADDQ $2, DI

 	// Return the number of bytes written.
 	SUBQ SI, DI
 	MOVQ DI, ret+40(FP)
 	RET

 step3:
 	// Emit the remaining copy, encoded as 3 bytes.
 	SUBL $1, AX
 	SHLB $2, AX
 	ORB  $2, AX
 	MOVB AX, 0(DI)
 	MOVW R11, 1(DI)
 	ADDQ $3, DI

 	// Return the number of bytes written.
 	SUBQ SI, DI
 	MOVQ DI, ret+40(FP)
 	RET

 // ----------------------------------------------------------------------------

 // func extendMatch(src []byte, i, j int) int
 //
 // All local variables fit into registers. The register allocation:
 //	- DX	&src[0]
 //	- SI	&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
 	MOVQ src_base+0(FP), DX
 	MOVQ src_len+8(FP), R14
 	MOVQ i+24(FP), R15
 	MOVQ j+32(FP), SI
 	ADDQ DX, R14
 	ADDQ DX, R15
 	ADDQ DX, SI
 	MOVQ R14, R13
 	SUBQ $8, 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.
 	CMPQ SI, R13
 	JA   cmp1
 	MOVQ (R15), AX
 	MOVQ (SI), BX
 	CMPQ AX, BX
 	JNE  bsf
 	ADDQ $8, R15
 	ADDQ $8, SI
 	JMP  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. The BSF instruction finds the
 	// least significant 1 bit, the amd64 architecture is little-endian, and
 	// the shift by 3 converts a bit index to a byte index.
 	XORQ AX, BX
 	BSFQ BX, BX
 	SHRQ $3, BX
 	ADDQ BX, SI

 	// Convert from &src[ret] to ret.
 	SUBQ DX, SI
 	MOVQ SI, ret+40(FP)
 	RET

 cmp1:
 	// In src's tail, compare 1 byte at a time.
 	CMPQ SI, R14
 	JAE  extendMatchEnd
 	MOVB (R15), AX
 	MOVB (SI), BX
 	CMPB AX, BX
 	JNE  extendMatchEnd
 	ADDQ $1, R15
 	ADDQ $1, SI
 	JMP  cmp1

 extendMatchEnd:
 	// Convert from &src[ret] to ret.
 	SUBQ DX, SI
 	MOVQ SI, ret+40(FP)
 	RET

 // ----------------------------------------------------------------------------

 // func encodeBlock(dst, src []byte) (d int)
 //
 // All local variables fit into registers, other than "var table". The register
 // allocation:
 //	- AX	.	.
 //	- BX	.	.
 //	- CX	56	shift (note that amd64 shifts by non-immediates must use CX).
 //	- DX	64	&src[0], tableSize
 //	- SI	72	&src[s]
 //	- DI	80	&dst[d]
 //	- R9	88	sLimit
 //	- R10	.	&src[nextEmit]
 //	- R11	96	prevHash, currHash, nextHash, offset
 //	- R12	104	&src[base], skip
 //	- R13	.	&src[nextS], &src[len(src) - 8]
 //	- R14	.	len(src), bytesBetweenHashLookups, &src[len(src)], x
 //	- R15	112	candidate
 //
 // The second column (56, 64, 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 56 bytes, to call other functions, and an extra 64 bytes, to spill
 // local variables (registers) during calls gives 32768 + 56 + 64 = 32888.
 TEXT ·encodeBlock(SB), 0, $32888-56
 	MOVQ dst_base+0(FP), DI
 	MOVQ src_base+24(FP), SI
 	MOVQ src_len+32(FP), R14

 	// shift, tableSize := uint32(32-8), 1<<8
 	MOVQ $24, CX
 	MOVQ $256, DX

 calcShift:
 	// for ; tableSize < maxTableSize && tableSize < len(src); tableSize *= 2 {
 	//	shift--
 	// }
 	CMPQ DX, $16384
 	JGE  varTable
 	CMPQ DX, R14
 	JGE  varTable
 	SUBQ $1, CX
 	SHLQ $1, DX
 	JMP  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 MOVOU
 	// writes 16 bytes, so we can do only tableSize/8 writes instead of the
 	// 2048 writes that would zero-initialize all of table's 32768 bytes.
 	SHRQ $3, DX
 	LEAQ table-32768(SP), BX
 	PXOR X0, X0

 memclr:
 	MOVOU X0, 0(BX)
 	ADDQ  $16, BX
 	SUBQ  $1, DX
 	JNZ   memclr

 	// !!! DX = &src[0]
 	MOVQ SI, DX

 	// sLimit := len(src) - inputMargin
 	MOVQ R14, R9
 	SUBQ $15, R9

 	// !!! Pre-emptively spill CX, DX and R9 to the stack. Their values don't
 	// change for the rest of the function.
 	MOVQ CX, 56(SP)
 	MOVQ DX, 64(SP)
 	MOVQ R9, 88(SP)

 	// nextEmit := 0
 	MOVQ DX, R10

 	// s := 1
 	ADDQ $1, SI

 	// nextHash := hash(load32(src, s), shift)
 	MOVL  0(SI), R11
 	IMULL $0x1e35a7bd, R11
 	SHRL  CX, R11

 outer:
 	// for { etc }

 	// skip := 32
 	MOVQ $32, R12

 	// nextS := s
 	MOVQ SI, R13

 	// candidate := 0
 	MOVQ $0, R15

 inner0:
 	// for { etc }

 	// s := nextS
 	MOVQ R13, SI

 	// bytesBetweenHashLookups := skip >> 5
 	MOVQ R12, R14
 	SHRQ $5, R14

 	// nextS = s + bytesBetweenHashLookups
 	ADDQ R14, R13

 	// skip += bytesBetweenHashLookups
 	ADDQ R14, R12

 	// if nextS > sLimit { goto emitRemainder }
 	MOVQ R13, AX
 	SUBQ DX, AX
 	CMPQ AX, R9
 	JA   emitRemainder

 	// candidate = int(table[nextHash])
 	// XXX: MOVWQZX table-32768(SP)(R11*2), R15
 	// XXX: 4e 0f b7 7c 5c 78       movzwq 0x78(%rsp,%r11,2),%r15
 	BYTE $0x4e
 	BYTE $0x0f
 	BYTE $0xb7
 	BYTE $0x7c
 	BYTE $0x5c
 	BYTE $0x78

 	// table[nextHash] = uint16(s)
 	MOVQ SI, AX
 	SUBQ DX, AX

 	// XXX: MOVW AX, table-32768(SP)(R11*2)
 	// XXX: 66 42 89 44 5c 78       mov    %ax,0x78(%rsp,%r11,2)
 	BYTE $0x66
 	BYTE $0x42
 	BYTE $0x89
 	BYTE $0x44
 	BYTE $0x5c
 	BYTE $0x78

 	// nextHash = hash(load32(src, nextS), shift)
 	MOVL  0(R13), R11
 	IMULL $0x1e35a7bd, R11
 	SHRL  CX, R11

 	// if load32(src, s) != load32(src, candidate) { continue } break
 	MOVL 0(SI), AX
 	MOVL (DX)(R15*1), BX
 	CMPL AX, BX
 	JNE  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.
 	MOVQ SI, AX
 	SUBQ R10, AX
 	CMPQ AX, $16
 	JLE  emitLiteralFastPath

 	// ----------------------------------------
 	// Begin inline of the emitLiteral call.
 	//
 	// d += emitLiteral(dst[d:], src[nextEmit:s])

 	MOVL AX, BX
 	SUBL $1, BX

 	CMPL BX, $60
 	JLT  inlineEmitLiteralOneByte
 	CMPL BX, $256
 	JLT  inlineEmitLiteralTwoBytes

 inlineEmitLiteralThreeBytes:
 	MOVB $0xf4, 0(DI)
 	MOVW BX, 1(DI)
 	ADDQ $3, DI
 	JMP  inlineEmitLiteralMemmove

 inlineEmitLiteralTwoBytes:
 	MOVB $0xf0, 0(DI)
 	MOVB BX, 1(DI)
 	ADDQ $2, DI
 	JMP  inlineEmitLiteralMemmove

 inlineEmitLiteralOneByte:
 	SHLB $2, BX
 	MOVB BX, 0(DI)
 	ADDQ $1, DI

 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
 	// DI, R10 and AX as arguments.
 	MOVQ DI, 0(SP)
 	MOVQ R10, 8(SP)
 	MOVQ AX, 16(SP)
 	ADDQ AX, DI              // Finish the "d +=" part of "d += emitLiteral(etc)".
 	MOVQ SI, 72(SP)
 	MOVQ DI, 80(SP)
 	MOVQ R15, 112(SP)
 	CALL runtime·memmove(SB)
 	MOVQ 56(SP), CX
 	MOVQ 64(SP), DX
 	MOVQ 72(SP), SI
 	MOVQ 80(SP), DI
 	MOVQ 88(SP), R9
 	MOVQ 112(SP), R15
 	JMP  inner1

 inlineEmitLiteralEnd:
 	// End inline of the emitLiteral call.
 	// ----------------------------------------

 emitLiteralFastPath:
 	// !!! Emit the 1-byte encoding "uint8(len(lit)-1)<<2".
 	MOVB AX, BX
 	SUBB $1, BX
 	SHLB $2, BX
 	MOVB BX, (DI)
 	ADDQ $1, DI

 	// !!! 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 amd64, 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.
 	MOVOU 0(R10), X0
 	MOVOU X0, 0(DI)
 	ADDQ  AX, DI

 inner1:
 	// for { etc }

 	// base := s
 	MOVQ SI, R12

 	// !!! offset := base - candidate
 	MOVQ R12, R11
 	SUBQ R15, R11
 	SUBQ DX, R11

 	// ----------------------------------------
 	// Begin inline of the extendMatch call.
 	//
 	// s = extendMatch(src, candidate+4, s+4)

 	// !!! R14 = &src[len(src)]
 	MOVQ src_len+32(FP), R14
 	ADDQ DX, R14

 	// !!! R13 = &src[len(src) - 8]
 	MOVQ R14, R13
 	SUBQ $8, R13

 	// !!! R15 = &src[candidate + 4]
 	ADDQ $4, R15
 	ADDQ DX, R15

 	// !!! s += 4
 	ADDQ $4, SI

 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.
 	CMPQ SI, R13
 	JA   inlineExtendMatchCmp1
 	MOVQ (R15), AX
 	MOVQ (SI), BX
 	CMPQ AX, BX
 	JNE  inlineExtendMatchBSF
 	ADDQ $8, R15
 	ADDQ $8, SI
 	JMP  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. The BSF instruction finds the
 	// least significant 1 bit, the amd64 architecture is little-endian, and
 	// the shift by 3 converts a bit index to a byte index.
 	XORQ AX, BX
 	BSFQ BX, BX
 	SHRQ $3, BX
 	ADDQ BX, SI
 	JMP  inlineExtendMatchEnd

 inlineExtendMatchCmp1:
 	// In src's tail, compare 1 byte at a time.
 	CMPQ SI, R14
 	JAE  inlineExtendMatchEnd
 	MOVB (R15), AX
 	MOVB (SI), BX
 	CMPB AX, BX
 	JNE  inlineExtendMatchEnd
 	ADDQ $1, R15
 	ADDQ $1, SI
 	JMP  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
 	MOVQ SI, AX
 	SUBQ R12, AX

 inlineEmitCopyLoop0:
 	// for length >= 68 { etc }
 	CMPL AX, $68
 	JLT  inlineEmitCopyStep1

 	// Emit a length 64 copy, encoded as 3 bytes.
 	MOVB $0xfe, 0(DI)
 	MOVW R11, 1(DI)
 	ADDQ $3, DI
 	SUBL $64, AX
 	JMP  inlineEmitCopyLoop0

 inlineEmitCopyStep1:
 	// if length > 64 { etc }
 	CMPL AX, $64
 	JLE  inlineEmitCopyStep2

 	// Emit a length 60 copy, encoded as 3 bytes.
 	MOVB $0xee, 0(DI)
 	MOVW R11, 1(DI)
 	ADDQ $3, DI
 	SUBL $60, AX

 inlineEmitCopyStep2:
 	// if length >= 12 || offset >= 2048 { goto inlineEmitCopyStep3 }
 	CMPL AX, $12
 	JGE  inlineEmitCopyStep3
 	CMPL R11, $2048
 	JGE  inlineEmitCopyStep3

 	// Emit the remaining copy, encoded as 2 bytes.
 	MOVB R11, 1(DI)
 	SHRL $8, R11
 	SHLB $5, R11
 	SUBB $4, AX
 	SHLB $2, AX
 	ORB  AX, R11
 	ORB  $1, R11
 	MOVB R11, 0(DI)
 	ADDQ $2, DI
 	JMP  inlineEmitCopyEnd

 inlineEmitCopyStep3:
 	// Emit the remaining copy, encoded as 3 bytes.
 	SUBL $1, AX
 	SHLB $2, AX
 	ORB  $2, AX
 	MOVB AX, 0(DI)
 	MOVW R11, 1(DI)
 	ADDQ $3, DI

 inlineEmitCopyEnd:
 	// End inline of the emitCopy call.
 	// ----------------------------------------

 	// nextEmit = s
 	MOVQ SI, R10

 	// if s >= sLimit { goto emitRemainder }
 	MOVQ SI, AX
 	SUBQ DX, AX
 	CMPQ AX, R9
 	JAE  emitRemainder

 	// As per the encode_other.go code:
 	//
 	// We could immediately etc.

 	// x := load64(src, s-1)
 	MOVQ -1(SI), R14

 	// prevHash := hash(uint32(x>>0), shift)
 	MOVL  R14, R11
 	IMULL $0x1e35a7bd, R11
 	SHRL  CX, R11

 	// table[prevHash] = uint16(s-1)
 	MOVQ SI, AX
 	SUBQ DX, AX
 	SUBQ $1, AX

 	// XXX: MOVW AX, table-32768(SP)(R11*2)
 	// XXX: 66 42 89 44 5c 78       mov    %ax,0x78(%rsp,%r11,2)
 	BYTE $0x66
 	BYTE $0x42
 	BYTE $0x89
 	BYTE $0x44
 	BYTE $0x5c
 	BYTE $0x78

 	// currHash := hash(uint32(x>>8), shift)
 	SHRQ  $8, R14
 	MOVL  R14, R11
 	IMULL $0x1e35a7bd, R11
 	SHRL  CX, R11

 	// candidate = int(table[currHash])
 	// XXX: MOVWQZX table-32768(SP)(R11*2), R15
 	// XXX: 4e 0f b7 7c 5c 78       movzwq 0x78(%rsp,%r11,2),%r15
 	BYTE $0x4e
 	BYTE $0x0f
 	BYTE $0xb7
 	BYTE $0x7c
 	BYTE $0x5c
 	BYTE $0x78

 	// table[currHash] = uint16(s)
 	ADDQ $1, AX

 	// XXX: MOVW AX, table-32768(SP)(R11*2)
 	// XXX: 66 42 89 44 5c 78       mov    %ax,0x78(%rsp,%r11,2)
 	BYTE $0x66
 	BYTE $0x42
 	BYTE $0x89
 	BYTE $0x44
 	BYTE $0x5c
 	BYTE $0x78

 	// if uint32(x>>8) == load32(src, candidate) { continue }
 	MOVL (DX)(R15*1), BX
 	CMPL R14, BX
 	JEQ  inner1

 	// nextHash = hash(uint32(x>>16), shift)
 	SHRQ  $8, R14
 	MOVL  R14, R11
 	IMULL $0x1e35a7bd, R11
 	SHRL  CX, R11

 	// s++
 	ADDQ $1, SI

 	// break out of the inner1 for loop, i.e. continue the outer loop.
 	JMP outer

 emitRemainder:
 	// if nextEmit < len(src) { etc }
 	MOVQ src_len+32(FP), AX
 	ADDQ DX, AX
 	CMPQ R10, AX
 	JEQ  encodeBlockEnd

 	// d += emitLiteral(dst[d:], src[nextEmit:])
 	//
 	// Push args.
 	MOVQ DI, 0(SP)
 	MOVQ $0, 8(SP)   // Unnecessary, as the callee ignores it, but conservative.
 	MOVQ $0, 16(SP)  // Unnecessary, as the callee ignores it, but conservative.
 	MOVQ R10, 24(SP)
 	SUBQ R10, AX
 	MOVQ AX, 32(SP)
 	MOVQ AX, 40(SP)  // Unnecessary, as the callee ignores it, but conservative.

 	// Spill local variables (registers) onto the stack; call; unspill.
 	MOVQ DI, 80(SP)
 	CALL ·emitLiteral(SB)
 	MOVQ 80(SP), DI

 	// Finish the "d +=" part of "d += emitLiteral(etc)".
 	ADDQ 48(SP), DI

 encodeBlockEnd:
 	MOVQ dst_base+0(FP), AX
 	SUBQ AX, DI
 	MOVQ DI, d+48(FP)
 	RET
	// Copyright 2016 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 XXX lines assemble on Go 1.4, 1.5 and 1.7, but not 1.6, due to a
	// Go toolchain regression. See https://github.com/golang/go/issues/15426 and
	// https://github.com/golang/snappy/issues/29
	//
	// As a workaround, the package was built with a known good assembler, and
	// those instructions were disassembled by "objdump -d" to yield the
	// 4e 0f b7 7c 5c 78 movzwq 0x78(%rsp,%r11,2),%r15
	// style comments, in AT&T asm syntax. Note that rsp here is a physical
	// register, not Go/asm's SP pseudo-register (see https://golang.org/doc/asm).
	// The instructions were then encoded as "BYTE $0x.." sequences, which assemble
	// fine on Go 1.6.

	// 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:
	// - AX len(lit)
	// - BX n
	// - DX return value
	// - DI &dst[i]
	// - R10 &lit[0]
	//
	// The 24 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, $24-56
	MOVQ dst_base+0(FP), DI
	MOVQ lit_base+24(FP), R10
	MOVQ lit_len+32(FP), AX
	MOVQ AX, DX
	MOVL AX, BX
	SUBL $1, BX

	CMPL BX, $60
	JLT oneByte
	CMPL BX, $256
	JLT twoBytes

	threeBytes:
	MOVB $0xf4, 0(DI)
	MOVW BX, 1(DI)
	ADDQ $3, DI
	ADDQ $3, DX
	JMP memmove

	twoBytes:
	MOVB $0xf0, 0(DI)
	MOVB BX, 1(DI)
	ADDQ $2, DI
	ADDQ $2, DX
	JMP memmove

	oneByte:
	SHLB $2, BX
	MOVB BX, 0(DI)
	ADDQ $1, DI
	ADDQ $1, DX

	memmove:
	MOVQ DX, ret+48(FP)

	// copy(dst[i:], lit)
	//
	// This means calling runtime·memmove(&dst[i], &lit[0], len(lit)), so we push
	// DI, R10 and AX as arguments.
	MOVQ DI, 0(SP)
	MOVQ R10, 8(SP)
	MOVQ AX, 16(SP)
	CALL runtime·memmove(SB)
	RET

	// ----------------------------------------------------------------------------

	// func emitCopy(dst []byte, offset, length int) int
	//
	// All local variables fit into registers. The register allocation:
	// - AX length
	// - SI &dst[0]
	// - DI &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
	MOVQ dst_base+0(FP), DI
	MOVQ DI, SI
	MOVQ offset+24(FP), R11
	MOVQ length+32(FP), AX

	loop0:
	// for length >= 68 { etc }
	CMPL AX, $68
	JLT step1

	// Emit a length 64 copy, encoded as 3 bytes.
	MOVB $0xfe, 0(DI)
	MOVW R11, 1(DI)
	ADDQ $3, DI
	SUBL $64, AX
	JMP loop0

	step1:
	// if length > 64 { etc }
	CMPL AX, $64
	JLE step2

	// Emit a length 60 copy, encoded as 3 bytes.
	MOVB $0xee, 0(DI)
	MOVW R11, 1(DI)
	ADDQ $3, DI
	SUBL $60, AX

	step2:
	// if length >= 12 \|\| offset >= 2048 { goto step3 }
	CMPL AX, $12
	JGE step3
	CMPL R11, $2048
	JGE step3

	// Emit the remaining copy, encoded as 2 bytes.
	MOVB R11, 1(DI)
	SHRL $8, R11
	SHLB $5, R11
	SUBB $4, AX
	SHLB $2, AX
	ORB AX, R11
	ORB $1, R11
	MOVB R11, 0(DI)
	ADDQ $2, DI

	// Return the number of bytes written.
	SUBQ SI, DI
	MOVQ DI, ret+40(FP)
	RET

	step3:
	// Emit the remaining copy, encoded as 3 bytes.
	SUBL $1, AX
	SHLB $2, AX
	ORB $2, AX
	MOVB AX, 0(DI)
	MOVW R11, 1(DI)
	ADDQ $3, DI

	// Return the number of bytes written.
	SUBQ SI, DI
	MOVQ DI, ret+40(FP)
	RET

	// ----------------------------------------------------------------------------

	// func extendMatch(src []byte, i, j int) int
	//
	// All local variables fit into registers. The register allocation:
	// - DX &src[0]
	// - SI &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
	MOVQ src_base+0(FP), DX
	MOVQ src_len+8(FP), R14
	MOVQ i+24(FP), R15
	MOVQ j+32(FP), SI
	ADDQ DX, R14
	ADDQ DX, R15
	ADDQ DX, SI
	MOVQ R14, R13
	SUBQ $8, 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.
	CMPQ SI, R13
	JA cmp1
	MOVQ (R15), AX
	MOVQ (SI), BX
	CMPQ AX, BX
	JNE bsf
	ADDQ $8, R15
	ADDQ $8, SI
	JMP 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. The BSF instruction finds the
	// least significant 1 bit, the amd64 architecture is little-endian, and
	// the shift by 3 converts a bit index to a byte index.
	XORQ AX, BX
	BSFQ BX, BX
	SHRQ $3, BX
	ADDQ BX, SI

	// Convert from &src[ret] to ret.
	SUBQ DX, SI
	MOVQ SI, ret+40(FP)
	RET

	cmp1:
	// In src's tail, compare 1 byte at a time.
	CMPQ SI, R14
	JAE extendMatchEnd
	MOVB (R15), AX
	MOVB (SI), BX
	CMPB AX, BX
	JNE extendMatchEnd
	ADDQ $1, R15
	ADDQ $1, SI
	JMP cmp1

	extendMatchEnd:
	// Convert from &src[ret] to ret.
	SUBQ DX, SI
	MOVQ SI, ret+40(FP)
	RET

	// ----------------------------------------------------------------------------

	// func encodeBlock(dst, src []byte) (d int)
	//
	// All local variables fit into registers, other than "var table". The register
	// allocation:
	// - AX . .
	// - BX . .
	// - CX 56 shift (note that amd64 shifts by non-immediates must use CX).
	// - DX 64 &src[0], tableSize
	// - SI 72 &src[s]
	// - DI 80 &dst[d]
	// - R9 88 sLimit
	// - R10 . &src[nextEmit]
	// - R11 96 prevHash, currHash, nextHash, offset
	// - R12 104 &src[base], skip
	// - R13 . &src[nextS], &src[len(src) - 8]
	// - R14 . len(src), bytesBetweenHashLookups, &src[len(src)], x
	// - R15 112 candidate
	//
	// The second column (56, 64, 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 56 bytes, to call other functions, and an extra 64 bytes, to spill
	// local variables (registers) during calls gives 32768 + 56 + 64 = 32888.
	TEXT ·encodeBlock(SB), 0, $32888-56
	MOVQ dst_base+0(FP), DI
	MOVQ src_base+24(FP), SI
	MOVQ src_len+32(FP), R14

	// shift, tableSize := uint32(32-8), 1<<8
	MOVQ $24, CX
	MOVQ $256, DX

	calcShift:
	// for ; tableSize < maxTableSize && tableSize < len(src); tableSize *= 2 {
	// shift--
	// }
	CMPQ DX, $16384
	JGE varTable
	CMPQ DX, R14
	JGE varTable
	SUBQ $1, CX
	SHLQ $1, DX
	JMP 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 MOVOU
	// writes 16 bytes, so we can do only tableSize/8 writes instead of the
	// 2048 writes that would zero-initialize all of table's 32768 bytes.
	SHRQ $3, DX
	LEAQ table-32768(SP), BX
	PXOR X0, X0

	memclr:
	MOVOU X0, 0(BX)
	ADDQ $16, BX
	SUBQ $1, DX
	JNZ memclr

	// !!! DX = &src[0]
	MOVQ SI, DX

	// sLimit := len(src) - inputMargin
	MOVQ R14, R9
	SUBQ $15, R9

	// !!! Pre-emptively spill CX, DX and R9 to the stack. Their values don't
	// change for the rest of the function.
	MOVQ CX, 56(SP)
	MOVQ DX, 64(SP)
	MOVQ R9, 88(SP)

	// nextEmit := 0
	MOVQ DX, R10

	// s := 1
	ADDQ $1, SI

	// nextHash := hash(load32(src, s), shift)
	MOVL 0(SI), R11
	IMULL $0x1e35a7bd, R11
	SHRL CX, R11

	outer:
	// for { etc }

	// skip := 32
	MOVQ $32, R12

	// nextS := s
	MOVQ SI, R13

	// candidate := 0
	MOVQ $0, R15

	inner0:
	// for { etc }

	// s := nextS
	MOVQ R13, SI

	// bytesBetweenHashLookups := skip >> 5
	MOVQ R12, R14
	SHRQ $5, R14

	// nextS = s + bytesBetweenHashLookups
	ADDQ R14, R13

	// skip += bytesBetweenHashLookups
	ADDQ R14, R12

	// if nextS > sLimit { goto emitRemainder }
	MOVQ R13, AX
	SUBQ DX, AX
	CMPQ AX, R9
	JA emitRemainder

	// candidate = int(table[nextHash])
	// XXX: MOVWQZX table-32768(SP)(R11*2), R15
	// XXX: 4e 0f b7 7c 5c 78 movzwq 0x78(%rsp,%r11,2),%r15
	BYTE $0x4e
	BYTE $0x0f
	BYTE $0xb7
	BYTE $0x7c
	BYTE $0x5c
	BYTE $0x78

	// table[nextHash] = uint16(s)
	MOVQ SI, AX
	SUBQ DX, AX

	// XXX: MOVW AX, table-32768(SP)(R11*2)
	// XXX: 66 42 89 44 5c 78 mov %ax,0x78(%rsp,%r11,2)
	BYTE $0x66
	BYTE $0x42
	BYTE $0x89
	BYTE $0x44
	BYTE $0x5c
	BYTE $0x78

	// nextHash = hash(load32(src, nextS), shift)
	MOVL 0(R13), R11
	IMULL $0x1e35a7bd, R11
	SHRL CX, R11

	// if load32(src, s) != load32(src, candidate) { continue } break
	MOVL 0(SI), AX
	MOVL (DX)(R15*1), BX
	CMPL AX, BX
	JNE 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.
	MOVQ SI, AX
	SUBQ R10, AX
	CMPQ AX, $16
	JLE emitLiteralFastPath

	// ----------------------------------------
	// Begin inline of the emitLiteral call.
	//
	// d += emitLiteral(dst[d:], src[nextEmit:s])

	MOVL AX, BX
	SUBL $1, BX

	CMPL BX, $60
	JLT inlineEmitLiteralOneByte
	CMPL BX, $256
	JLT inlineEmitLiteralTwoBytes

	inlineEmitLiteralThreeBytes:
	MOVB $0xf4, 0(DI)
	MOVW BX, 1(DI)
	ADDQ $3, DI
	JMP inlineEmitLiteralMemmove

	inlineEmitLiteralTwoBytes:
	MOVB $0xf0, 0(DI)
	MOVB BX, 1(DI)
	ADDQ $2, DI
	JMP inlineEmitLiteralMemmove

	inlineEmitLiteralOneByte:
	SHLB $2, BX
	MOVB BX, 0(DI)
	ADDQ $1, DI

	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
	// DI, R10 and AX as arguments.
	MOVQ DI, 0(SP)
	MOVQ R10, 8(SP)
	MOVQ AX, 16(SP)
	ADDQ AX, DI // Finish the "d +=" part of "d += emitLiteral(etc)".
	MOVQ SI, 72(SP)
	MOVQ DI, 80(SP)
	MOVQ R15, 112(SP)
	CALL runtime·memmove(SB)
	MOVQ 56(SP), CX
	MOVQ 64(SP), DX
	MOVQ 72(SP), SI
	MOVQ 80(SP), DI
	MOVQ 88(SP), R9
	MOVQ 112(SP), R15
	JMP inner1

	inlineEmitLiteralEnd:
	// End inline of the emitLiteral call.
	// ----------------------------------------

	emitLiteralFastPath:
	// !!! Emit the 1-byte encoding "uint8(len(lit)-1)<<2".
	MOVB AX, BX
	SUBB $1, BX
	SHLB $2, BX
	MOVB BX, (DI)
	ADDQ $1, DI

	// !!! 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 amd64, 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.
	MOVOU 0(R10), X0
	MOVOU X0, 0(DI)
	ADDQ AX, DI

	inner1:
	// for { etc }

	// base := s
	MOVQ SI, R12

	// !!! offset := base - candidate
	MOVQ R12, R11
	SUBQ R15, R11
	SUBQ DX, R11

	// ----------------------------------------
	// Begin inline of the extendMatch call.
	//
	// s = extendMatch(src, candidate+4, s+4)

	// !!! R14 = &src[len(src)]
	MOVQ src_len+32(FP), R14
	ADDQ DX, R14

	// !!! R13 = &src[len(src) - 8]
	MOVQ R14, R13
	SUBQ $8, R13

	// !!! R15 = &src[candidate + 4]
	ADDQ $4, R15
	ADDQ DX, R15

	// !!! s += 4
	ADDQ $4, SI

	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.
	CMPQ SI, R13
	JA inlineExtendMatchCmp1
	MOVQ (R15), AX
	MOVQ (SI), BX
	CMPQ AX, BX
	JNE inlineExtendMatchBSF
	ADDQ $8, R15
	ADDQ $8, SI
	JMP 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. The BSF instruction finds the
	// least significant 1 bit, the amd64 architecture is little-endian, and
	// the shift by 3 converts a bit index to a byte index.
	XORQ AX, BX
	BSFQ BX, BX
	SHRQ $3, BX
	ADDQ BX, SI
	JMP inlineExtendMatchEnd

	inlineExtendMatchCmp1:
	// In src's tail, compare 1 byte at a time.
	CMPQ SI, R14
	JAE inlineExtendMatchEnd
	MOVB (R15), AX
	MOVB (SI), BX
	CMPB AX, BX
	JNE inlineExtendMatchEnd
	ADDQ $1, R15
	ADDQ $1, SI
	JMP 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
	MOVQ SI, AX
	SUBQ R12, AX

	inlineEmitCopyLoop0:
	// for length >= 68 { etc }
	CMPL AX, $68
	JLT inlineEmitCopyStep1

	// Emit a length 64 copy, encoded as 3 bytes.
	MOVB $0xfe, 0(DI)
	MOVW R11, 1(DI)
	ADDQ $3, DI
	SUBL $64, AX
	JMP inlineEmitCopyLoop0

	inlineEmitCopyStep1:
	// if length > 64 { etc }
	CMPL AX, $64
	JLE inlineEmitCopyStep2

	// Emit a length 60 copy, encoded as 3 bytes.
	MOVB $0xee, 0(DI)
	MOVW R11, 1(DI)
	ADDQ $3, DI
	SUBL $60, AX

	inlineEmitCopyStep2:
	// if length >= 12 \|\| offset >= 2048 { goto inlineEmitCopyStep3 }
	CMPL AX, $12
	JGE inlineEmitCopyStep3
	CMPL R11, $2048
	JGE inlineEmitCopyStep3

	// Emit the remaining copy, encoded as 2 bytes.
	MOVB R11, 1(DI)
	SHRL $8, R11
	SHLB $5, R11
	SUBB $4, AX
	SHLB $2, AX
	ORB AX, R11
	ORB $1, R11
	MOVB R11, 0(DI)
	ADDQ $2, DI
	JMP inlineEmitCopyEnd

	inlineEmitCopyStep3:
	// Emit the remaining copy, encoded as 3 bytes.
	SUBL $1, AX
	SHLB $2, AX
	ORB $2, AX
	MOVB AX, 0(DI)
	MOVW R11, 1(DI)
	ADDQ $3, DI

	inlineEmitCopyEnd:
	// End inline of the emitCopy call.
	// ----------------------------------------

	// nextEmit = s
	MOVQ SI, R10

	// if s >= sLimit { goto emitRemainder }
	MOVQ SI, AX
	SUBQ DX, AX
	CMPQ AX, R9
	JAE emitRemainder

	// As per the encode_other.go code:
	//
	// We could immediately etc.

	// x := load64(src, s-1)
	MOVQ -1(SI), R14

	// prevHash := hash(uint32(x>>0), shift)
	MOVL R14, R11
	IMULL $0x1e35a7bd, R11
	SHRL CX, R11

	// table[prevHash] = uint16(s-1)
	MOVQ SI, AX
	SUBQ DX, AX
	SUBQ $1, AX

	// XXX: MOVW AX, table-32768(SP)(R11*2)
	// XXX: 66 42 89 44 5c 78 mov %ax,0x78(%rsp,%r11,2)
	BYTE $0x66
	BYTE $0x42
	BYTE $0x89
	BYTE $0x44
	BYTE $0x5c
	BYTE $0x78

	// currHash := hash(uint32(x>>8), shift)
	SHRQ $8, R14
	MOVL R14, R11
	IMULL $0x1e35a7bd, R11
	SHRL CX, R11

	// candidate = int(table[currHash])
	// XXX: MOVWQZX table-32768(SP)(R11*2), R15
	// XXX: 4e 0f b7 7c 5c 78 movzwq 0x78(%rsp,%r11,2),%r15
	BYTE $0x4e
	BYTE $0x0f
	BYTE $0xb7
	BYTE $0x7c
	BYTE $0x5c
	BYTE $0x78

	// table[currHash] = uint16(s)
	ADDQ $1, AX

	// XXX: MOVW AX, table-32768(SP)(R11*2)
	// XXX: 66 42 89 44 5c 78 mov %ax,0x78(%rsp,%r11,2)
	BYTE $0x66
	BYTE $0x42
	BYTE $0x89
	BYTE $0x44
	BYTE $0x5c
	BYTE $0x78

	// if uint32(x>>8) == load32(src, candidate) { continue }
	MOVL (DX)(R15*1), BX
	CMPL R14, BX
	JEQ inner1

	// nextHash = hash(uint32(x>>16), shift)
	SHRQ $8, R14
	MOVL R14, R11
	IMULL $0x1e35a7bd, R11
	SHRL CX, R11

	// s++
	ADDQ $1, SI

	// break out of the inner1 for loop, i.e. continue the outer loop.
	JMP outer

	emitRemainder:
	// if nextEmit < len(src) { etc }
	MOVQ src_len+32(FP), AX
	ADDQ DX, AX
	CMPQ R10, AX
	JEQ encodeBlockEnd

	// d += emitLiteral(dst[d:], src[nextEmit:])
	//
	// Push args.
	MOVQ DI, 0(SP)
	MOVQ $0, 8(SP) // Unnecessary, as the callee ignores it, but conservative.
	MOVQ $0, 16(SP) // Unnecessary, as the callee ignores it, but conservative.
	MOVQ R10, 24(SP)
	SUBQ R10, AX
	MOVQ AX, 32(SP)
	MOVQ AX, 40(SP) // Unnecessary, as the callee ignores it, but conservative.

	// Spill local variables (registers) onto the stack; call; unspill.
	MOVQ DI, 80(SP)
	CALL ·emitLiteral(SB)
	MOVQ 80(SP), DI

	// Finish the "d +=" part of "d += emitLiteral(etc)".
	ADDQ 48(SP), DI

	encodeBlockEnd:
	MOVQ dst_base+0(FP), AX
	SUBQ AX, DI
	MOVQ DI, d+48(FP)
	RET