@ttsc/win32-arm64 0.33.0 → 0.34.0

package/bin/go/VERSION

@@ -1,2 +1,2 @@
-go1.26.9
-time 2026-10-02T20:28:03Z
+go1.27.3
+time 2026-10-19T22:20:36Z

package/bin/go/lib/time/update.bash

@@ -24,8 +24,8 @@
 # in the CL match the update.bash in the CL.
 
 # Versions to use.
-CODE=2025c
-DATA=2025c
+CODE=2026c
+DATA=2026c
 
 set -e
 

package/bin/go/pkg/include/asm_ppc64x.h

@@ -37,19 +37,3 @@
 	GLOBL	funcname(SB), NOPTR, $24
 #endif
 #endif
-
-// linux/ppc64 uses ELFv1 which uses function descriptors.
-// These must also look like ABI0 functions on linux/ppc64
-// to work with abi.FuncPCABI0(sigtramp) in os_linux.go.
-// Only static codegen is supported on linux/ppc64, so TOC
-// is not needed.
-#ifdef GOOS_linux
-#ifdef GOARCH_ppc64
-#define GO_PPC64X_HAS_FUNCDESC
-#define DEFINE_PPC64X_FUNCDESC(funcname, localfuncname)	\
-	TEXT	funcname(SB),NOSPLIT|NOFRAME,$0		\
-		DWORD	$localfuncname(SB)		\
-		DWORD	$0				\
-		DWORD	$0
-#endif
-#endif

package/bin/go/src/archive/tar/reader.go

@@ -45,8 +45,9 @@ func NewReader(r io.Reader) *Reader {
 // Any remaining data in the current file is automatically discarded.
 // At the end of the archive, Next returns the error io.EOF.
 //
-// If Next encounters a non-local name (as defined by [filepath.IsLocal])
+// If Next encounters a non-local file name (as defined by [filepath.IsLocal])
 // and the GODEBUG environment variable contains `tarinsecurepath=0`,
+// Only file names are validated, not link targets.
 // Next returns the header with an [ErrInsecurePath] error.
 // A future version of Go may introduce this behavior by default.
 // Programs that want to accept non-local names can ignore

package/bin/go/src/archive/zip/reader.go

@@ -63,7 +63,6 @@ type File struct {
 	zip          *Reader
 	zipr         io.ReaderAt
 	headerOffset int64 // includes overall ZIP archive baseOffset
-	zip64        bool  // zip64 extended information extra field presence
 }
 
 // OpenReader will open the Zip file specified by name and return a ReadCloser.
@@ -406,10 +405,6 @@ func readDirectoryHeader(f *File, r io.Reader) error {
 		f.NonUTF8 = f.Flags&0x800 == 0
 	}
 
-	needUSize := f.UncompressedSize == ^uint32(0)
-	needCSize := f.CompressedSize == ^uint32(0)
-	needHeaderOffset := f.headerOffset == int64(^uint32(0))
-
 	// Best effort to find what we need.
 	// Other zip authors might not even follow the basic format,
 	// and we'll just ignore the Extra content in that case.
@@ -425,28 +420,23 @@ parseExtras:
 
 		switch fieldTag {
 		case zip64ExtraID:
-			f.zip64 = true
-
 			// update directory values from the zip64 extra block.
 			// They should only be consulted if the sizes read earlier
 			// are maxed out.
-			// See golang.org/issue/13367.
-			if needUSize {
-				needUSize = false
+			// See go.dev/issue/13367 and go.dev/issue/31692.
+			if f.UncompressedSize == ^uint32(0) {
 				if len(fieldBuf) < 8 {
 					return ErrFormat
 				}
 				f.UncompressedSize64 = fieldBuf.uint64()
 			}
-			if needCSize {
-				needCSize = false
+			if f.CompressedSize == ^uint32(0) {
 				if len(fieldBuf) < 8 {
 					return ErrFormat
 				}
 				f.CompressedSize64 = fieldBuf.uint64()
 			}
-			if needHeaderOffset {
-				needHeaderOffset = false
+			if f.headerOffset == int64(^uint32(0)) {
 				if len(fieldBuf) < 8 {
 					return ErrFormat
 				}
@@ -509,20 +499,6 @@ parseExtras:
 		}
 	}
 
-	// Assume that uncompressed size 2³²-1 could plausibly happen in
-	// an old zip32 file that was sharding inputs into the largest chunks
-	// possible (or is just malicious; search the web for 42.zip).
-	// If needUSize is true still, it means we didn't see a zip64 extension.
-	// As long as the compressed size is not also 2³²-1 (implausible)
-	// and the header is not also 2³²-1 (equally implausible),
-	// accept the uncompressed size 2³²-1 as valid.
-	// If nothing else, this keeps archive/zip working with 42.zip.
-	_ = needUSize
-
-	if needCSize || needHeaderOffset {
-		return ErrFormat
-	}
-
 	return nil
 }
 
@@ -605,7 +581,7 @@ func readDirectoryEnd(r io.ReaderAt, size int64) (dir *directoryEnd, baseOffset
 	d.comment = string(b[:l])
 
 	// These values mean that the file can be a zip64 file
-	if d.directoryRecords == 0xffff || d.directorySize == 0xffff || d.directoryOffset == 0xffffffff {
+	if d.directoryRecords == 0xffff || d.directorySize == 0xffffffff || d.directoryOffset == 0xffffffff {
 		p, err := findDirectory64End(r, directoryEndOffset)
 		if err == nil && p >= 0 {
 			directoryEndOffset = p

package/bin/go/src/archive/zip/struct.go

@@ -156,7 +156,11 @@ type FileHeader struct {
 	// UncompressedSize64 is the uncompressed size of the file in bytes.
 	UncompressedSize64 uint64
 
-	Extra         []byte
+	// Extra are the extensible data fields. The writer automatically includes
+	// the appropriate Zip64 field if necessary, and [Writer.Close] appends the
+	// Central Directory version of the Zip64 field to Extra.
+	Extra []byte
+
 	ExternalAttrs uint32 // Meaning depends on CreatorVersion
 }
 
@@ -337,11 +341,6 @@ func (h *FileHeader) SetMode(mode fs.FileMode) {
 	}
 }
 
-// isZip64 reports whether the file size exceeds the 32 bit limit
-func (h *FileHeader) isZip64() bool {
-	return h.CompressedSize64 >= uint32max || h.UncompressedSize64 >= uint32max
-}
-
 func (h *FileHeader) hasDataDescriptor() bool {
 	return h.Flags&0x8 != 0
 }

package/bin/go/src/archive/zip/writer.go

@@ -42,6 +42,10 @@ type header struct {
 }
 
 // NewWriter returns a new [Writer] writing a zip file to w.
+//
+// Note that the exact bytes written to w are not covered by the Go 1
+// compatibility promise. Callers, including tests, should not depend on the
+// exact written bytes.
 func NewWriter(w io.Writer) *Writer {
 	return &Writer{cw: &countWriter{w: bufio.NewWriter(w)}}
 }
@@ -89,48 +93,65 @@ func (w *Writer) Close() error {
 
 	// write central directory
 	start := w.cw.count
+	usedZip64 := false
 	for _, h := range w.dir {
+		// For the Central Directory, we always have the correct sizes.
+		//
+		// Implementations disagree on what triggers the inclusion of a Zip64
+		// extra field: Info-ZIP only writes it if any size or offset EXCEEDS
+		// 4GiB - 1, while libarchive writes it if any size REACHES OR EXCEEDS
+		// 4GiB - 1, or if the offset EXCEEDS 4GiB - 1. The spec is ambiguous.
+		//
+		// We conservatively write Zip64 extra fields if any size or offset
+		// REACHES OR EXCEEDS 4GiB - 1, to maximize compatibility with readers.
+		// There is no ambiguity in parsing, so there is no downside to it.
+		//
+		// The spec is clear though that all and only the fields that REACH OR
+		// EXCEED 4GiB - 1 are included in the Zip64 extra, once it's present.
+		readerVersion := h.ReaderVersion
+		if h.CompressedSize64 >= uint32max || h.UncompressedSize64 >= uint32max || h.offset >= uint32max {
+			usedZip64 = true
+			readerVersion = max(readerVersion, zipVersion45)
+			var size uint16
+			var buf [28]byte // 2x uint16 + up to 3x uint64
+			eb := writeBuf(buf[:])
+			eb.uint16(zip64ExtraID)
+			eb.uint16(0) // size to be filled out later
+			if h.UncompressedSize64 >= uint32max {
+				eb.uint64(h.UncompressedSize64)
+				size += 8
+			}
+			if h.CompressedSize64 >= uint32max {
+				eb.uint64(h.CompressedSize64)
+				size += 8
+			}
+			if h.offset >= uint32max {
+				eb.uint64(h.offset)
+				size += 8
+			}
+			sb := writeBuf(buf[2:])
+			sb.uint16(size)
+			h.Extra = append(h.Extra, buf[:4+size]...)
+		}
+
 		var buf [directoryHeaderLen]byte
 		b := writeBuf(buf[:])
 		b.uint32(uint32(directoryHeaderSignature))
 		b.uint16(h.CreatorVersion)
-		b.uint16(h.ReaderVersion)
+		b.uint16(readerVersion)
 		b.uint16(h.Flags)
 		b.uint16(h.Method)
 		b.uint16(h.ModifiedTime)
 		b.uint16(h.ModifiedDate)
 		b.uint32(h.CRC32)
-		if h.isZip64() || h.offset >= uint32max {
-			// the file needs a zip64 header. store maxint in both
-			// 32 bit size fields (and offset later) to signal that the
-			// zip64 extra header should be used.
-			b.uint32(uint32max) // compressed size
-			b.uint32(uint32max) // uncompressed size
-
-			// append a zip64 extra block to Extra
-			var buf [28]byte // 2x uint16 + 3x uint64
-			eb := writeBuf(buf[:])
-			eb.uint16(zip64ExtraID)
-			eb.uint16(24) // size = 3x uint64
-			eb.uint64(h.UncompressedSize64)
-			eb.uint64(h.CompressedSize64)
-			eb.uint64(h.offset)
-			h.Extra = append(h.Extra, buf[:]...)
-		} else {
-			b.uint32(h.CompressedSize)
-			b.uint32(h.UncompressedSize)
-		}
-
+		b.uint32(uint32(min(h.CompressedSize64, uint32max)))
+		b.uint32(uint32(min(h.UncompressedSize64, uint32max)))
 		b.uint16(uint16(len(h.Name)))
 		b.uint16(uint16(len(h.Extra)))
 		b.uint16(uint16(len(h.Comment)))
 		b = b[4:] // skip disk number start and internal file attr (2x uint16)
 		b.uint32(h.ExternalAttrs)
-		if h.offset > uint32max {
-			b.uint32(uint32max)
-		} else {
-			b.uint32(uint32(h.offset))
-		}
+		b.uint32(uint32(min(h.offset, uint32max)))
 		if _, err := w.cw.Write(buf[:]); err != nil {
 			return err
 		}
@@ -154,7 +175,11 @@ func (w *Writer) Close() error {
 		f(size, offset)
 	}
 
-	if records >= uint16max || size >= uint32max || offset >= uint32max {
+	// Emit the Zip64 EOCD records whenever any individual entry needed a Zip64
+	// extra field, even if the EOCD's own fields fit in 32 bits, matching
+	// Info-ZIP (but not libarchive). See APPNOTE 4.3.9.2: "when Zip64
+	// extensions are in use, the EOCD64 record must be present."
+	if usedZip64 || records >= uint16max || size >= uint32max || offset >= uint32max {
 		var buf [directory64EndLen + directory64LocLen]byte
 		b := writeBuf(buf[:])
 
@@ -179,24 +204,18 @@ func (w *Writer) Close() error {
 		if _, err := w.cw.Write(buf[:]); err != nil {
 			return err
 		}
-
-		// store max values in the regular end record to signal
-		// that the zip64 values should be used instead
-		records = uint16max
-		size = uint32max
-		offset = uint32max
 	}
 
 	// write end record
 	var buf [directoryEndLen]byte
 	b := writeBuf(buf[:])
 	b.uint32(uint32(directoryEndSignature))
-	b = b[4:]                        // skip over disk number and first disk number (2x uint16)
-	b.uint16(uint16(records))        // number of entries this disk
-	b.uint16(uint16(records))        // number of entries total
-	b.uint32(uint32(size))           // size of directory
-	b.uint32(uint32(offset))         // start of directory
-	b.uint16(uint16(len(w.comment))) // byte size of EOCD comment
+	b = b[4:]                                 // skip over disk number and first disk number (2x uint16)
+	b.uint16(uint16(min(uint16max, records))) // number of entries this disk
+	b.uint16(uint16(min(uint16max, records))) // number of entries total
+	b.uint32(uint32(min(uint32max, size)))    // size of directory
+	b.uint32(uint32(min(uint32max, offset)))  // start of directory
+	b.uint16(uint16(len(w.comment)))          // byte size of EOCD comment
 	if _, err := w.cw.Write(buf[:]); err != nil {
 		return err
 	}
@@ -394,38 +413,79 @@ func writeHeader(w io.Writer, h *header) error {
 		return errLongExtra
 	}
 
+	// The correct behavior of a streaming writer, implemented by Info-ZIP 3.0,
+	// would be to write 0xFFFFFFFF in the size fields and then write a Zip64
+	// extra field with the sizes at zero (to signal they are stored in a ZIP64
+	// data descriptor, in case the file is > 4GiB).
+	//
+	// We don't do that, and instead write zeroes directly in the size fields,
+	// because that wastes 28 bytes for every file smaller than 4GiB, and
+	// because it would change the encoding of nearly every zip file created by
+	// archive/zip. (No one should rely on it being stable, but still.)
+	//
+	// Anyway, the Local File Header is not that important, as the Central
+	// Directory is authoritative, and there we always write the correct sizes.
+	//
+	// If we do know the sizes, because [Writer.CreateRaw] is used and the data
+	// descriptor flag is not set, then we write them to the header. If either
+	// size reaches 4GiB, we write 0xFFFFFFFF placeholders and a Zip64 extra
+	// field with BOTH sizes, per the spec and matching Info-ZIP. Note this is
+	// different from the Central Directory Zip64 extra field logic, somehow.
+	//
+	// (One final interesting case that doesn't apply to us: if the input is
+	// streaming but the output is seekable, Info-ZIP always writes Zip64 extra
+	// fields, and then goes back and patches in the sizes, even for files < 4GiB.)
+
+	var zip64ExtraInfo []byte
+	readerVersion := h.ReaderVersion
+	noDataDescriptor := h.raw && !h.hasDataDescriptor()
+	if noDataDescriptor && (h.CompressedSize64 > uint32max || h.UncompressedSize64 > uint32max) {
+		readerVersion = max(readerVersion, zipVersion45)
+		zip64ExtraInfo = make([]byte, 20) // 2x uint16 + 2x uint64
+		b := writeBuf(zip64ExtraInfo)
+		b.uint16(zip64ExtraID)
+		b.uint16(16) // size of Zip64 extra field data
+		b.uint64(h.UncompressedSize64)
+		b.uint64(h.CompressedSize64)
+	}
+
 	var buf [fileHeaderLen]byte
 	b := writeBuf(buf[:])
 	b.uint32(uint32(fileHeaderSignature))
-	b.uint16(h.ReaderVersion)
+	b.uint16(readerVersion)
 	b.uint16(h.Flags)
 	b.uint16(h.Method)
 	b.uint16(h.ModifiedTime)
 	b.uint16(h.ModifiedDate)
-	// In raw mode (caller does the compression), the values are either
-	// written here or in the trailing data descriptor based on the header
-	// flags.
-	if h.raw && !h.hasDataDescriptor() {
+	if noDataDescriptor {
 		b.uint32(h.CRC32)
-		b.uint32(uint32(min(h.CompressedSize64, uint32max)))
-		b.uint32(uint32(min(h.UncompressedSize64, uint32max)))
+		if zip64ExtraInfo != nil {
+			b.uint32(uint32max)
+			b.uint32(uint32max)
+		} else {
+			b.uint32(uint32(h.CompressedSize64))
+			b.uint32(uint32(h.UncompressedSize64))
+		}
 	} else {
-		// When this package handle the compression, these values are
-		// always written to the trailing data descriptor.
 		b.uint32(0) // crc32
 		b.uint32(0) // compressed size
 		b.uint32(0) // uncompressed size
 	}
 	b.uint16(uint16(len(h.Name)))
-	b.uint16(uint16(len(h.Extra)))
+	b.uint16(uint16(len(h.Extra) + len(zip64ExtraInfo)))
 	if _, err := w.Write(buf[:]); err != nil {
 		return err
 	}
 	if _, err := io.WriteString(w, h.Name); err != nil {
 		return err
 	}
-	_, err := w.Write(h.Extra)
-	return err
+	if _, err := w.Write(h.Extra); err != nil {
+		return err
+	}
+	if _, err := w.Write(zip64ExtraInfo); err != nil {
+		return err
+	}
+	return nil
 }
 
 // CreateRaw adds a file to the zip archive using the provided [FileHeader] and
@@ -597,7 +657,7 @@ func (w *fileWriter) close() error {
 	fh.CompressedSize64 = uint64(w.compCount.count)
 	fh.UncompressedSize64 = uint64(w.rawCount.count)
 
-	if fh.isZip64() {
+	if w.CompressedSize64 > uint32max || w.UncompressedSize64 > uint32max {
 		fh.CompressedSize = uint32max
 		fh.UncompressedSize = uint32max
 		fh.ReaderVersion = zipVersion45 // requires 4.5 - File uses ZIP64 format extensions
@@ -613,13 +673,13 @@ func (w *fileWriter) writeDataDescriptor() error {
 	if !w.hasDataDescriptor() {
 		return nil
 	}
-	// Write data descriptor. This is more complicated than one would
-	// think, see e.g. comments in zipfile.c:putextended() and
-	// https://bugs.openjdk.org/browse/JDK-7073588.
-	// The approach here is to write 8 byte sizes if needed without
-	// adding a zip64 extra in the local header (too late anyway).
+	// See the comment in [writeHeader] about how and why we don't signal ZIP64
+	// mode in the local file header. If one of the sizes turns out to exceed
+	// 4GiB, we use the 64-bit sizes anyway, for lack of alternatives.
+	//
+	// See also https://bugs.openjdk.org/browse/JDK-7073588.
 	var buf []byte
-	if w.isZip64() {
+	if w.CompressedSize64 > uint32max || w.UncompressedSize64 > uint32max {
 		buf = make([]byte, dataDescriptor64Len)
 	} else {
 		buf = make([]byte, dataDescriptorLen)
@@ -627,7 +687,7 @@ func (w *fileWriter) writeDataDescriptor() error {
 	b := writeBuf(buf)
 	b.uint32(dataDescriptorSignature) // de-facto standard, required by OS X
 	b.uint32(w.CRC32)
-	if w.isZip64() {
+	if w.CompressedSize64 > uint32max || w.UncompressedSize64 > uint32max {
 		b.uint64(w.CompressedSize64)
 		b.uint64(w.UncompressedSize64)
 	} else {

package/bin/go/src/bufio/bufio.go

@@ -30,7 +30,7 @@ var (
 
 // Reader implements buffering for an io.Reader object.
 // A new Reader is created by calling [NewReader] or [NewReaderSize];
-// alternatively the zero value of a Reader may be used after calling [Reset]
+// alternatively the zero value of a Reader may be used after calling [Reader.Reset]
 // on it.
 type Reader struct {
 	buf          []byte

package/bin/go/src/bytes/buffer.go

@@ -311,9 +311,9 @@ func (b *Buffer) WriteByte(c byte) error {
 }
 
 // WriteRune appends the UTF-8 encoding of Unicode code point r to the
-// buffer, returning its length and an error, which is always nil but is
-// included to match [bufio.Writer]'s WriteRune. The buffer is grown as needed;
-// if it becomes too large, WriteRune will panic with [ErrTooLarge].
+// buffer, returning the number of bytes written and a nil error. The nil
+// error is included to match [bufio.Writer]'s WriteRune. The buffer is grown
+// as needed; if it becomes too large, WriteRune will panic with [ErrTooLarge].
 func (b *Buffer) WriteRune(r rune) (n int, err error) {
 	// Compare as uint32 to correctly handle negative runes.
 	if uint32(r) < utf8.RuneSelf {

package/bin/go/src/bytes/bytes.go

@@ -89,6 +89,7 @@ func ContainsRune(b []byte, r rune) bool {
 }
 
 // ContainsFunc reports whether any of the UTF-8-encoded code points r within b satisfy f(r).
+// It stops as soon as a call to f returns true.
 func ContainsFunc(b []byte, f func(rune) bool) bool {
 	return IndexFunc(b, f) >= 0
 }
@@ -98,15 +99,6 @@ func IndexByte(b []byte, c byte) int {
 	return bytealg.IndexByte(b, c)
 }
 
-func indexBytePortable(s []byte, c byte) int {
-	for i, b := range s {
-		if b == c {
-			return i
-		}
-	}
-	return -1
-}
-
 // LastIndex returns the index of the last instance of sep in s, or -1 if sep is not present in s.
 func LastIndex(s, sep []byte) int {
 	n := len(sep)
@@ -246,7 +238,7 @@ func IndexAny(s []byte, chars string) int {
 		}
 		return IndexRune(s, r)
 	}
-	if len(s) > 8 {
+	if shouldUseASCIISet(len(s)) {
 		if as, isASCII := makeASCIISet(chars); isASCII {
 			for i, c := range s {
 				if as.contains(c) {
@@ -301,7 +293,7 @@ func LastIndexAny(s []byte, chars string) int {
 		// Avoid scanning all of s.
 		return -1
 	}
-	if len(s) > 8 {
+	if shouldUseASCIISet(len(s)) {
 		if as, isASCII := makeASCIISet(chars); isASCII {
 			for i := len(s) - 1; i >= 0; i-- {
 				if as.contains(s[i]) {
@@ -388,9 +380,7 @@ func genSplit(s, sep []byte, sepSave, n int) [][]byte {
 	if n < 0 {
 		n = Count(s, sep) + 1
 	}
-	if n > len(s)+1 {
-		n = len(s) + 1
-	}
+	n = min(n, len(s)+1)
 
 	a := make([][]byte, n)
 	n--
@@ -935,15 +925,22 @@ func lastIndexFunc(s []byte, f func(r rune) bool, truth bool) int {
 	return -1
 }
 
-// asciiSet is a 32-byte value, where each bit represents the presence of a
-// given ASCII character in the set. The 128-bits of the lower 16 bytes,
-// starting with the least-significant bit of the lowest word to the
-// most-significant bit of the highest word, map to the full range of all
-// 128 ASCII characters. The 128-bits of the upper 16 bytes will be zeroed,
-// ensuring that any non-ASCII character will be reported as not in the set.
-// This allocates a total of 32 bytes even though the upper half
-// is unused to avoid bounds checks in asciiSet.contains.
-type asciiSet [8]uint32
+// asciiSet is a 256-byte lookup table for fast ASCII character membership testing.
+// Each element corresponds to an ASCII character value, with true indicating the
+// character is in the set. Using bool instead of byte allows the compiler to
+// eliminate the comparison instruction, as bool values are guaranteed to be 0 or 1.
+//
+// The full 256-element table is used rather than a 128-element table to avoid
+// additional operations in the lookup path. Alternative approaches were tested:
+//   - [128]bool with explicit bounds check (if c >= 128): introduces branches
+//     that cause pipeline stalls, resulting in ~70% slower performance
+//   - [128]bool with masking (c&0x7f): eliminates bounds checks but the AND
+//     operation still costs ~10% performance compared to direct indexing
+//
+// The 256-element array allows direct indexing with no bounds checks, no branches,
+// and no masking operations, providing optimal performance. The additional 128 bytes
+// of memory is a worthwhile tradeoff for the simpler, faster code.
+type asciiSet [256]bool
 
 // makeASCIISet creates a set of ASCII characters and reports whether all
 // characters in chars are ASCII.
@@ -953,14 +950,24 @@ func makeASCIISet(chars string) (as asciiSet, ok bool) {
 		if c >= utf8.RuneSelf {
 			return as, false
 		}
-		as[c/32] |= 1 << (c % 32)
+		as[c] = true
 	}
 	return as, true
 }
 
 // contains reports whether c is inside the set.
 func (as *asciiSet) contains(c byte) bool {
-	return (as[c/32] & (1 << (c % 32))) != 0
+	return as[c]
+}
+
+// shouldUseASCIISet returns whether to use the lookup table optimization.
+// The threshold of 8 bytes balances initialization cost against per-byte
+// search cost, performing well across all charset sizes.
+//
+// More complex heuristics (e.g., different thresholds per charset size)
+// add branching overhead that eats away any theoretical improvements.
+func shouldUseASCIISet(bufLen int) bool {
+	return bufLen > 8
 }
 
 // containsRune is a simplified version of strings.ContainsRune
@@ -1413,3 +1420,16 @@ func CutSuffix(s, suffix []byte) (before []byte, found bool) {
 	}
 	return s[:len(s)-len(suffix)], true
 }
+
+// CutLast slices s around the last instance of sep,
+// returning the text before and after sep.
+// The found result reports whether sep appears in s.
+// If sep does not appear in s, CutLast returns s, nil, false.
+//
+// CutLast returns slices of the original slice s, not copies.
+func CutLast(s, sep []byte) (before, after []byte, found bool) {
+	if i := LastIndex(s, sep); i >= 0 {
+		return s[:i], s[i+len(sep):], true
+	}
+	return s, nil, false
+}