Rearrange the extendMatch register allocation.

This minimizes the diff in a follow-up commit, when manually inlining.

It's not an optimization per se, but for the record:
name              old speed      new speed      delta
WordsEncode1e1-8   700MB/s ± 1%   701MB/s ± 0%    ~     (p=0.393 n=10+10)
WordsEncode1e2-8   460MB/s ± 1%   460MB/s ± 0%    ~     (p=0.393 n=10+10)
WordsEncode1e3-8   478MB/s ± 2%   480MB/s ± 0%    ~     (p=0.912 n=10+10)
WordsEncode1e4-8   414MB/s ± 0%   416MB/s ± 0%  +0.64%   (p=0.000 n=9+10)
WordsEncode1e5-8   296MB/s ± 1%   297MB/s ± 0%    ~      (p=0.113 n=9+10)
WordsEncode1e6-8   345MB/s ± 0%   345MB/s ± 0%    ~      (p=0.949 n=8+10)
RandomEncode-8    14.4GB/s ± 2%  14.4GB/s ± 2%    ~      (p=0.278 n=9+10)
_ZFlat0-8          888MB/s ± 1%   891MB/s ± 1%  +0.35%   (p=0.010 n=10+9)
_ZFlat1-8          471MB/s ± 1%   471MB/s ± 0%    ~      (p=0.447 n=10+9)
_ZFlat2-8         16.2GB/s ± 3%  16.2GB/s ± 3%    ~     (p=0.912 n=10+10)
_ZFlat3-8          675MB/s ± 1%   676MB/s ± 0%    ~      (p=0.150 n=9+10)
_ZFlat4-8         8.31GB/s ± 1%  8.36GB/s ± 1%  +0.65%  (p=0.035 n=10+10)
_ZFlat5-8          850MB/s ± 0%   852MB/s ± 0%    ~      (p=0.182 n=9+10)
_ZFlat6-8          316MB/s ± 0%   316MB/s ± 0%    ~      (p=0.762 n=10+8)
_ZFlat7-8          294MB/s ± 1%   296MB/s ± 0%  +0.51%    (p=0.006 n=9+8)
_ZFlat8-8          330MB/s ± 1%   331MB/s ± 1%    ~       (p=0.881 n=9+9)
_ZFlat9-8          273MB/s ± 0%   274MB/s ± 0%  +0.23%   (p=0.043 n=10+8)
_ZFlat10-8        1.17GB/s ± 1%  1.17GB/s ± 0%    ~      (p=0.922 n=10+9)
_ZFlat11-8         461MB/s ± 0%   462MB/s ± 0%    ~      (p=0.219 n=10+9)

Also:
name           old time/op  new time/op  delta
ExtendMatch-8  7.92µs ± 2%  7.80µs ± 2%  -1.51%  (p=0.002 n=10+9)
and note that this is time/op instead of MB/s, so negative is better,
although it's quite possibly all just noise.

encode_amd64.s

@@ -169,33 +169,37 @@ step3:
 // func extendMatch(src []byte, i, j int) int
 //
 // All local variables fit into registers. The register allocation:
-//	- CX	&src[0]
-//	- DX	&src[len(src)]
-//	- SI	&src[i]
-//	- DI	&src[j]
-//	- R9	&src[len(src) - 8]
+//	- 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), CX
-	MOVQ src_len+8(FP), DX
-	MOVQ i+24(FP), SI
-	MOVQ j+32(FP), DI
-	ADDQ CX, DX
-	ADDQ CX, SI
-	ADDQ CX, DI
-	MOVQ DX, R9
-	SUBQ $8, R9
+	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 DI, R9
+	CMPQ SI, R13
 	JA   cmp1
-	MOVQ (SI), AX
-	MOVQ (DI), BX
+	MOVQ (R15), AX
+	MOVQ (SI), BX
 	CMPQ AX, BX
 	JNE  bsf
+	ADDQ $8, R15
 	ADDQ $8, SI
-	ADDQ $8, DI
 	JMP  cmp8
 
 bsf:
@@ -206,29 +210,29 @@ bsf:
 	XORQ AX, BX
 	BSFQ BX, BX
 	SHRQ $3, BX
-	ADDQ BX, DI
+	ADDQ BX, SI
 
 	// Convert from &src[ret] to ret.
-	SUBQ CX, DI
-	MOVQ DI, ret+40(FP)
+	SUBQ DX, SI
+	MOVQ SI, ret+40(FP)
 	RET
 
 cmp1:
 	// In src's tail, compare 1 byte at a time.
-	CMPQ DI, DX
+	CMPQ SI, R14
 	JAE  extendMatchEnd
-	MOVB (SI), AX
-	MOVB (DI), BX
+	MOVB (R15), AX
+	MOVB (SI), BX
 	CMPB AX, BX
 	JNE  extendMatchEnd
+	ADDQ $1, R15
 	ADDQ $1, SI
-	ADDQ $1, DI
 	JMP  cmp1
 
 extendMatchEnd:
 	// Convert from &src[ret] to ret.
-	SUBQ CX, DI
-	MOVQ DI, ret+40(FP)
+	SUBQ DX, SI
+	MOVQ SI, ret+40(FP)
 	RET
 
 // ----------------------------------------------------------------------------