@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/debug/dwarf/buf.go

@@ -146,7 +146,10 @@ func (b *buf) varint() (c uint64, bits uint) {
 
 // Unsigned int is just a varint.
 func (b *buf) uint() uint64 {
-	x, _ := b.varint()
+	x, bits := b.varint()
+	if bits == 0 {
+		b.error("underflow")
+	}
 	return x
 }
 
@@ -157,6 +160,9 @@ func (b *buf) int() int64 {
 	if x&(1<<(bits-1)) != 0 {
 		x |= -1 << bits
 	}
+	if bits == 0 {
+		b.error("underflow")
+	}
 	return x
 }
 

package/bin/go/src/debug/dwarf/class_string.go

@@ -35,8 +35,9 @@ const _Class_name = "ClassUnknownClassAddressClassBlockClassConstantClassExprLoc
 var _Class_index = [...]uint16{0, 12, 24, 34, 47, 59, 68, 80, 95, 106, 123, 137, 154, 165, 182, 196, 208, 220, 232, 248, 266}
 
 func (i Class) String() string {
-	if i < 0 || i >= Class(len(_Class_index)-1) {
+	idx := int(i) - 0
+	if i < 0 || idx >= len(_Class_index)-1 {
 		return "Class(" + strconv.FormatInt(int64(i), 10) + ")"
 	}
-	return _Class_name[_Class_index[i]:_Class_index[i+1]]
+	return _Class_name[_Class_index[idx]:_Class_index[idx+1]]
 }

package/bin/go/src/debug/elf/file.go

@@ -290,7 +290,7 @@ func NewFile(r io.ReaderAt) (*File, error) {
 	// Read and decode ELF identifier
 	var ident [16]uint8
 	if _, err := r.ReadAt(ident[0:], 0); err != nil {
-		return nil, err
+		return nil, &FormatError{0, "cannot read ELF identifier", err}
 	}
 	if ident[0] != '\x7f' || ident[1] != 'E' || ident[2] != 'L' || ident[3] != 'F' {
 		return nil, &FormatError{0, "bad magic number", ident[0:4]}
@@ -400,8 +400,81 @@ func NewFile(r io.ReaderAt) (*File, error) {
 		return nil, &FormatError{0, "invalid ELF phentsize", phentsize}
 	}
 
+	// If the number of sections is greater than or equal to SHN_LORESERVE
+	// (0xff00), shnum has the value zero and the actual number of section
+	// header table entries is contained in the sh_size field of the section
+	// header at index 0.
+	//
+	// If the number of segments is greater than or equal to 0xffff,
+	// phnum has the value 0xffff, and the actual number of segments
+	// is contained in the sh_info field of the section header at
+	// index 0.
+	const pnXnum = 0xffff
+	if shoff > 0 && (shnum == 0 || phnum == pnXnum) {
+		var typ, link, info uint32
+		var size uint64
+		sr.Seek(shoff, io.SeekStart)
+		switch f.Class {
+		case ELFCLASS32:
+			sh := new(Section32)
+			if err := binary.Read(sr, bo, sh); err != nil {
+				return nil, err
+			}
+			size = uint64(sh.Size)
+			typ = sh.Type
+			link = sh.Link
+			info = sh.Info
+		case ELFCLASS64:
+			sh := new(Section64)
+			if err := binary.Read(sr, bo, sh); err != nil {
+				return nil, err
+			}
+			size = sh.Size
+			typ = sh.Type
+			link = sh.Link
+			info = sh.Info
+		}
+
+		if SectionType(typ) != SHT_NULL {
+			return nil, &FormatError{shoff, "invalid type of the initial section", SectionType(typ)}
+		}
+
+		if shnum == 0 {
+			if size < uint64(SHN_LORESERVE) {
+				return nil, &FormatError{shoff, "invalid ELF shnum contained in sh_size", shnum}
+			}
+			shnum = int(size)
+		}
+
+		if phnum == pnXnum {
+			if info < 0xffff {
+				return nil, &FormatError{shoff, "invalid ELF phnum contained in sh_info", info}
+			}
+			phnum = int(info)
+		}
+
+		// If the section name string table section index is greater than or
+		// equal to SHN_LORESERVE (0xff00), this member has the value
+		// SHN_XINDEX (0xffff) and the actual index of the section name
+		// string table section is contained in the sh_link field of the
+		// section header at index 0.
+		if shstrndx == int(SHN_XINDEX) {
+			shstrndx = int(link)
+			if shstrndx < int(SHN_LORESERVE) || shstrndx >= shnum {
+				return nil, &FormatError{shoff, "invalid ELF shstrndx contained in sh_link", shstrndx}
+			}
+		}
+	}
+
 	// Read program headers
-	f.Progs = make([]*Prog, phnum)
+	c := saferio.SliceCap[*Prog](uint64(phnum))
+	if c < 0 {
+		return nil, &FormatError{0, "too many segments", phnum}
+	}
+	if phnum > 0 && ((1<<64)-1)/uint64(phnum) < uint64(phentsize) {
+		return nil, &FormatError{0, "segment header overflow", phnum}
+	}
+	f.Progs = make([]*Prog, 0, c)
 	phdata, err := saferio.ReadDataAt(sr, uint64(phnum)*uint64(phentsize), phoff)
 	if err != nil {
 		return nil, err
@@ -443,53 +516,7 @@ func NewFile(r io.ReaderAt) (*File, error) {
 		}
 		p.sr = io.NewSectionReader(r, int64(p.Off), int64(p.Filesz))
 		p.ReaderAt = p.sr
-		f.Progs[i] = p
-	}
-
-	// If the number of sections is greater than or equal to SHN_LORESERVE
-	// (0xff00), shnum has the value zero and the actual number of section
-	// header table entries is contained in the sh_size field of the section
-	// header at index 0.
-	if shoff > 0 && shnum == 0 {
-		var typ, link uint32
-		sr.Seek(shoff, io.SeekStart)
-		switch f.Class {
-		case ELFCLASS32:
-			sh := new(Section32)
-			if err := binary.Read(sr, bo, sh); err != nil {
-				return nil, err
-			}
-			shnum = int(sh.Size)
-			typ = sh.Type
-			link = sh.Link
-		case ELFCLASS64:
-			sh := new(Section64)
-			if err := binary.Read(sr, bo, sh); err != nil {
-				return nil, err
-			}
-			shnum = int(sh.Size)
-			typ = sh.Type
-			link = sh.Link
-		}
-		if SectionType(typ) != SHT_NULL {
-			return nil, &FormatError{shoff, "invalid type of the initial section", SectionType(typ)}
-		}
-
-		if shnum < int(SHN_LORESERVE) {
-			return nil, &FormatError{shoff, "invalid ELF shnum contained in sh_size", shnum}
-		}
-
-		// If the section name string table section index is greater than or
-		// equal to SHN_LORESERVE (0xff00), this member has the value
-		// SHN_XINDEX (0xffff) and the actual index of the section name
-		// string table section is contained in the sh_link field of the
-		// section header at index 0.
-		if shstrndx == int(SHN_XINDEX) {
-			shstrndx = int(link)
-			if shstrndx < int(SHN_LORESERVE) {
-				return nil, &FormatError{shoff, "invalid ELF shstrndx contained in sh_link", shstrndx}
-			}
-		}
+		f.Progs = append(f.Progs, p)
 	}
 
 	if shnum > 0 && shentsize < wantShentsize {
@@ -497,7 +524,7 @@ func NewFile(r io.ReaderAt) (*File, error) {
 	}
 
 	// Read section headers
-	c := saferio.SliceCap[Section](uint64(shnum))
+	c = saferio.SliceCap[Section](uint64(shnum))
 	if c < 0 {
 		return nil, &FormatError{0, "too many sections", shnum}
 	}
@@ -1525,6 +1552,9 @@ func (f *File) dynamicVersions(str []byte) error {
 				deps = append(deps, depName)
 			}
 
+			if vnext == 0 {
+				break
+			}
 			j += int(vnext)
 		}
 

package/bin/go/src/debug/elf/reader.go

@@ -11,7 +11,7 @@ import (
 
 // errorReader returns error from all operations.
 type errorReader struct {
-	error
+	error error
 }
 
 func (r errorReader) Read(p []byte) (n int, err error) {

package/bin/go/src/debug/gosym/symtab.go

@@ -34,22 +34,34 @@ type Sym struct {
 // Static reports whether this symbol is static (not visible outside its file).
 func (s *Sym) Static() bool { return s.Type >= 'a' }
 
-// nameWithoutInst returns s.Name if s.Name has no brackets (does not reference an
-// instantiated type, function, or method). If s.Name contains brackets, then it
-// returns s.Name with all the contents between (and including) the outermost left
-// and right bracket removed. This is useful to ignore any extra slashes or dots
-// inside the brackets from the string searches below, where needed.
+// nameWithoutInst returns s.Name with all bracketed expressions masked by
+// underscores. This is useful to ignore any extra slashes or dots inside the
+// brackets from the string searches below, while preserving the byte indices
+// of the characters outside the brackets.
+//
+// s.Name is returned as-is if the brackets are imbalanced.
 func (s *Sym) nameWithoutInst() string {
-	start := strings.Index(s.Name, "[")
-	if start < 0 {
-		return s.Name
+	n := 0
+	b := []byte(s.Name)
+	for i, r := range b {
+		switch r {
+		case '[':
+			n++
+		case ']':
+			n--
+			if n < 0 {
+				return s.Name // malformed
+			}
+		default:
+			if n > 0 {
+				b[i] = '_'
+			}
+		}
 	}
-	end := strings.LastIndex(s.Name, "]")
-	if end < 0 {
-		// Malformed name, should contain closing bracket too.
-		return s.Name
+	if n > 0 {
+		return s.Name // malformed
 	}
-	return s.Name[0:start] + s.Name[end+1:]
+	return string(b)
 }
 
 // PackageName returns the package part of the symbol name,
@@ -76,7 +88,7 @@ func (s *Sym) PackageName() string {
 	}
 
 	if i := strings.Index(name[pathend:], "."); i != -1 {
-		return name[:pathend+i]
+		return s.Name[:pathend+i]
 	}
 	return ""
 }
@@ -86,8 +98,6 @@ func (s *Sym) PackageName() string {
 // the case that s.Name is fully-specified with a package name.
 func (s *Sym) ReceiverName() string {
 	name := s.nameWithoutInst()
-	// If we find a slash in name, it should precede any bracketed expression
-	// that was removed, so pathend will apply correctly to name and s.Name.
 	pathend := strings.LastIndex(name, "/")
 	if pathend < 0 {
 		pathend = 0
@@ -101,10 +111,6 @@ func (s *Sym) ReceiverName() string {
 		// There is no receiver if we didn't find two distinct dots after pathend.
 		return ""
 	}
-	// Given there is a trailing '.' that is in name, find it now in s.Name.
-	// pathend+l should apply to s.Name, because it should be the dot in the
-	// package name.
-	r = strings.LastIndex(s.Name[pathend:], ".")
 	return s.Name[pathend+l+1 : pathend+r]
 }
 
@@ -112,16 +118,6 @@ func (s *Sym) ReceiverName() string {
 func (s *Sym) BaseName() string {
 	name := s.nameWithoutInst()
 	if i := strings.LastIndex(name, "."); i != -1 {
-		if s.Name != name {
-			brack := strings.Index(s.Name, "[")
-			if i > brack {
-				// BaseName is a method name after the brackets, so
-				// recalculate for s.Name. Otherwise, i applies
-				// correctly to s.Name, since it is before the
-				// brackets.
-				i = strings.LastIndex(s.Name, ".")
-			}
-		}
 		return s.Name[i+1:]
 	}
 	return s.Name

package/bin/go/src/debug/macho/file.go

@@ -646,12 +646,12 @@ func (f *File) DWARF() (*dwarf.Data, error) {
 
 		if len(b) >= 12 && string(b[:4]) == "ZLIB" {
 			dlen := binary.BigEndian.Uint64(b[4:12])
-			dbuf := make([]byte, dlen)
 			r, err := zlib.NewReader(bytes.NewBuffer(b[12:]))
 			if err != nil {
 				return nil, err
 			}
-			if _, err := io.ReadFull(r, dbuf); err != nil {
+			dbuf, err := saferio.ReadData(r, dlen)
+			if err != nil {
 				return nil, err
 			}
 			if err := r.Close(); err != nil {

package/bin/go/src/debug/macho/reloctype_string.go

@@ -21,10 +21,11 @@ const _RelocTypeGeneric_name = "GENERIC_RELOC_VANILLAGENERIC_RELOC_PAIRGENERIC_R
 var _RelocTypeGeneric_index = [...]uint8{0, 21, 39, 61, 84, 112, 129}
 
 func (i RelocTypeGeneric) String() string {
-	if i < 0 || i >= RelocTypeGeneric(len(_RelocTypeGeneric_index)-1) {
+	idx := int(i) - 0
+	if i < 0 || idx >= len(_RelocTypeGeneric_index)-1 {
 		return "RelocTypeGeneric(" + strconv.FormatInt(int64(i), 10) + ")"
 	}
-	return _RelocTypeGeneric_name[_RelocTypeGeneric_index[i]:_RelocTypeGeneric_index[i+1]]
+	return _RelocTypeGeneric_name[_RelocTypeGeneric_index[idx]:_RelocTypeGeneric_index[idx+1]]
 }
 func _() {
 	// An "invalid array index" compiler error signifies that the constant values have changed.
@@ -47,10 +48,11 @@ const _RelocTypeX86_64_name = "X86_64_RELOC_UNSIGNEDX86_64_RELOC_SIGNEDX86_64_RE
 var _RelocTypeX86_64_index = [...]uint8{0, 21, 40, 59, 80, 96, 119, 140, 161, 182, 198}
 
 func (i RelocTypeX86_64) String() string {
-	if i < 0 || i >= RelocTypeX86_64(len(_RelocTypeX86_64_index)-1) {
+	idx := int(i) - 0
+	if i < 0 || idx >= len(_RelocTypeX86_64_index)-1 {
 		return "RelocTypeX86_64(" + strconv.FormatInt(int64(i), 10) + ")"
 	}
-	return _RelocTypeX86_64_name[_RelocTypeX86_64_index[i]:_RelocTypeX86_64_index[i+1]]
+	return _RelocTypeX86_64_name[_RelocTypeX86_64_index[idx]:_RelocTypeX86_64_index[idx+1]]
 }
 func _() {
 	// An "invalid array index" compiler error signifies that the constant values have changed.
@@ -73,10 +75,11 @@ const _RelocTypeARM_name = "ARM_RELOC_VANILLAARM_RELOC_PAIRARM_RELOC_SECTDIFFARM
 var _RelocTypeARM_index = [...]uint8{0, 17, 31, 49, 73, 92, 106, 126, 148, 162, 185}
 
 func (i RelocTypeARM) String() string {
-	if i < 0 || i >= RelocTypeARM(len(_RelocTypeARM_index)-1) {
+	idx := int(i) - 0
+	if i < 0 || idx >= len(_RelocTypeARM_index)-1 {
 		return "RelocTypeARM(" + strconv.FormatInt(int64(i), 10) + ")"
 	}
-	return _RelocTypeARM_name[_RelocTypeARM_index[i]:_RelocTypeARM_index[i+1]]
+	return _RelocTypeARM_name[_RelocTypeARM_index[idx]:_RelocTypeARM_index[idx+1]]
 }
 func _() {
 	// An "invalid array index" compiler error signifies that the constant values have changed.
@@ -100,8 +103,9 @@ const _RelocTypeARM64_name = "ARM64_RELOC_UNSIGNEDARM64_RELOC_SUBTRACTORARM64_RE
 var _RelocTypeARM64_index = [...]uint16{0, 20, 42, 62, 80, 101, 128, 158, 184, 212, 243, 261}
 
 func (i RelocTypeARM64) String() string {
-	if i < 0 || i >= RelocTypeARM64(len(_RelocTypeARM64_index)-1) {
+	idx := int(i) - 0
+	if i < 0 || idx >= len(_RelocTypeARM64_index)-1 {
 		return "RelocTypeARM64(" + strconv.FormatInt(int64(i), 10) + ")"
 	}
-	return _RelocTypeARM64_name[_RelocTypeARM64_index[i]:_RelocTypeARM64_index[i+1]]
+	return _RelocTypeARM64_name[_RelocTypeARM64_index[idx]:_RelocTypeARM64_index[idx+1]]
 }

package/bin/go/src/debug/pe/file.go

@@ -22,6 +22,7 @@ import (
 	"encoding/binary"
 	"errors"
 	"fmt"
+	"internal/saferio"
 	"io"
 	"os"
 	"strings"
@@ -81,7 +82,9 @@ func NewFile(r io.ReaderAt) (*File, error) {
 	if dosheader[0] == 'M' && dosheader[1] == 'Z' {
 		signoff := int64(binary.LittleEndian.Uint32(dosheader[0x3c:]))
 		var sign [4]byte
-		r.ReadAt(sign[:], signoff)
+		if _, err := r.ReadAt(sign[:], signoff); err != nil {
+			return nil, err
+		}
 		if !(sign[0] == 'P' && sign[1] == 'E' && sign[2] == 0 && sign[3] == 0) {
 			return nil, fmt.Errorf("invalid PE file signature: % x", sign)
 		}
@@ -237,12 +240,12 @@ func (f *File) DWARF() (*dwarf.Data, error) {
 
 		if len(b) >= 12 && string(b[:4]) == "ZLIB" {
 			dlen := binary.BigEndian.Uint64(b[4:12])
-			dbuf := make([]byte, dlen)
 			r, err := zlib.NewReader(bytes.NewBuffer(b[12:]))
 			if err != nil {
 				return nil, err
 			}
-			if _, err := io.ReadFull(r, dbuf); err != nil {
+			dbuf, err := saferio.ReadData(r, dlen)
+			if err != nil {
 				return nil, err
 			}
 			if err := r.Close(); err != nil {

package/bin/go/src/encoding/base32/base32.go

@@ -127,61 +127,59 @@ func (enc *Encoding) Encode(dst, src []byte) {
 	// outside of the loop to speed up the encoder.
 	_ = enc.encode
 
-	di, si := 0, 0
-	n := (len(src) / 5) * 5
-	for si < n {
+	for len(src) >= 5 {
 		// Combining two 32 bit loads allows the same code to be used
 		// for 32 and 64 bit platforms.
-		hi := uint32(src[si+0])<<24 | uint32(src[si+1])<<16 | uint32(src[si+2])<<8 | uint32(src[si+3])
-		lo := hi<<8 | uint32(src[si+4])
+		hi := uint32(src[0])<<24 | uint32(src[1])<<16 | uint32(src[2])<<8 | uint32(src[3])
+		lo := hi<<8 | uint32(src[4])
 
-		dst[di+0] = enc.encode[(hi>>27)&0x1F]
-		dst[di+1] = enc.encode[(hi>>22)&0x1F]
-		dst[di+2] = enc.encode[(hi>>17)&0x1F]
-		dst[di+3] = enc.encode[(hi>>12)&0x1F]
-		dst[di+4] = enc.encode[(hi>>7)&0x1F]
-		dst[di+5] = enc.encode[(hi>>2)&0x1F]
-		dst[di+6] = enc.encode[(lo>>5)&0x1F]
-		dst[di+7] = enc.encode[(lo)&0x1F]
+		_ = dst[7] // Eliminate bounds checks below.
+		dst[0] = enc.encode[(hi>>27)&0x1F]
+		dst[1] = enc.encode[(hi>>22)&0x1F]
+		dst[2] = enc.encode[(hi>>17)&0x1F]
+		dst[3] = enc.encode[(hi>>12)&0x1F]
+		dst[4] = enc.encode[(hi>>7)&0x1F]
+		dst[5] = enc.encode[(hi>>2)&0x1F]
+		dst[6] = enc.encode[(lo>>5)&0x1F]
+		dst[7] = enc.encode[(lo)&0x1F]
 
-		si += 5
-		di += 8
+		src = src[5:]
+		dst = dst[8:]
 	}
 
 	// Add the remaining small block
-	remain := len(src) - si
-	if remain == 0 {
+	if len(src) == 0 {
 		return
 	}
 
 	// Encode the remaining bytes in reverse order.
 	val := uint32(0)
-	switch remain {
+	switch len(src) {
 	case 4:
-		val |= uint32(src[si+3])
-		dst[di+6] = enc.encode[val<<3&0x1F]
-		dst[di+5] = enc.encode[val>>2&0x1F]
+		val |= uint32(src[3])
+		dst[6] = enc.encode[val<<3&0x1F]
+		dst[5] = enc.encode[val>>2&0x1F]
 		fallthrough
 	case 3:
-		val |= uint32(src[si+2]) << 8
-		dst[di+4] = enc.encode[val>>7&0x1F]
+		val |= uint32(src[2]) << 8
+		dst[4] = enc.encode[val>>7&0x1F]
 		fallthrough
 	case 2:
-		val |= uint32(src[si+1]) << 16
-		dst[di+3] = enc.encode[val>>12&0x1F]
-		dst[di+2] = enc.encode[val>>17&0x1F]
+		val |= uint32(src[1]) << 16
+		dst[3] = enc.encode[val>>12&0x1F]
+		dst[2] = enc.encode[val>>17&0x1F]
 		fallthrough
 	case 1:
-		val |= uint32(src[si+0]) << 24
-		dst[di+1] = enc.encode[val>>22&0x1F]
-		dst[di+0] = enc.encode[val>>27&0x1F]
+		val |= uint32(src[0]) << 24
+		dst[1] = enc.encode[val>>22&0x1F]
+		dst[0] = enc.encode[val>>27&0x1F]
 	}
 
 	// Pad the final quantum
 	if enc.padChar != NoPadding {
-		nPad := (remain * 8 / 5) + 1
+		nPad := (len(src) * 8 / 5) + 1
 		for i := nPad; i < 8; i++ {
-			dst[di+i] = byte(enc.padChar)
+			dst[i] = byte(enc.padChar)
 		}
 	}
 }

package/bin/go/src/encoding/base64/base64.go

@@ -151,44 +151,39 @@ func (enc *Encoding) Encode(dst, src []byte) {
 	// outside of the loop to speed up the encoder.
 	_ = enc.encode
 
-	di, si := 0, 0
-	n := (len(src) / 3) * 3
-	for si < n {
+	for len(src) >= 3 {
 		// Convert 3x 8bit source bytes into 4 bytes
-		val := uint(src[si+0])<<16 | uint(src[si+1])<<8 | uint(src[si+2])
+		val := uint(src[0])<<16 | uint(src[1])<<8 | uint(src[2])
 
-		dst[di+0] = enc.encode[val>>18&0x3F]
-		dst[di+1] = enc.encode[val>>12&0x3F]
-		dst[di+2] = enc.encode[val>>6&0x3F]
-		dst[di+3] = enc.encode[val&0x3F]
+		_ = dst[3] // Eliminate bounds checks below.
+		dst[0] = enc.encode[val>>18&0x3F]
+		dst[1] = enc.encode[val>>12&0x3F]
+		dst[2] = enc.encode[val>>6&0x3F]
+		dst[3] = enc.encode[val&0x3F]
 
-		si += 3
-		di += 4
+		src = src[3:]
+		dst = dst[4:]
 	}
 
-	remain := len(src) - si
-	if remain == 0 {
+	// Add the remaining small block (if any).
+	switch len(src) {
+	case 0:
 		return
-	}
-	// Add the remaining small block
-	val := uint(src[si+0]) << 16
-	if remain == 2 {
-		val |= uint(src[si+1]) << 8
-	}
-
-	dst[di+0] = enc.encode[val>>18&0x3F]
-	dst[di+1] = enc.encode[val>>12&0x3F]
-
-	switch remain {
-	case 2:
-		dst[di+2] = enc.encode[val>>6&0x3F]
+	case 1:
+		val := uint(src[0]) << 16
+		dst[0] = enc.encode[val>>18&0x3F]
+		dst[1] = enc.encode[val>>12&0x3F]
 		if enc.padChar != NoPadding {
-			dst[di+3] = byte(enc.padChar)
+			dst[2] = byte(enc.padChar)
+			dst[3] = byte(enc.padChar)
 		}
-	case 1:
+	case 2:
+		val := uint(src[0])<<16 | uint(src[1])<<8
+		dst[0] = enc.encode[val>>18&0x3F]
+		dst[1] = enc.encode[val>>12&0x3F]
+		dst[2] = enc.encode[val>>6&0x3F]
 		if enc.padChar != NoPadding {
-			dst[di+2] = byte(enc.padChar)
-			dst[di+3] = byte(enc.padChar)
+			dst[3] = byte(enc.padChar)
 		}
 	}
 }

package/bin/go/src/encoding/gob/decode.go

@@ -594,7 +594,13 @@ func decodeIntoValue(state *decoderState, op decOp, isPtr bool, value reflect.Va
 func (dec *Decoder) decodeMap(mtyp reflect.Type, state *decoderState, value reflect.Value, keyOp, elemOp decOp, ovfl error) {
 	n := int(state.decodeUint())
 	if value.IsNil() {
-		value.Set(reflect.MakeMapWithSize(mtyp, n))
+		// This is a map, not a slice, but capping the
+		// size works either way.
+		safe := saferio.SliceCapWithSize(uint64(mtyp.Elem().Size()), uint64(n))
+		if safe < 0 {
+			safe = 1
+		}
+		value.Set(reflect.MakeMapWithSize(mtyp, safe))
 	}
 	keyIsPtr := mtyp.Key().Kind() == reflect.Pointer
 	elemIsPtr := mtyp.Elem().Kind() == reflect.Pointer

package/bin/go/src/encoding/gob/type.go

@@ -264,12 +264,12 @@ var (
 	tComplex   = bootstrapType("complex", (*complex128)(nil))
 	tInterface = bootstrapType("interface", (*any)(nil))
 	// Reserve some Ids for compatible expansion
-	tReserved7 = bootstrapType("_reserved1", (*struct{ r7 int })(nil))
-	tReserved6 = bootstrapType("_reserved1", (*struct{ r6 int })(nil))
-	tReserved5 = bootstrapType("_reserved1", (*struct{ r5 int })(nil))
-	tReserved4 = bootstrapType("_reserved1", (*struct{ r4 int })(nil))
-	tReserved3 = bootstrapType("_reserved1", (*struct{ r3 int })(nil))
-	tReserved2 = bootstrapType("_reserved1", (*struct{ r2 int })(nil))
+	tReserved7 = bootstrapType("_reserved7", (*struct{ r7 int })(nil))
+	tReserved6 = bootstrapType("_reserved6", (*struct{ r6 int })(nil))
+	tReserved5 = bootstrapType("_reserved5", (*struct{ r5 int })(nil))
+	tReserved4 = bootstrapType("_reserved4", (*struct{ r4 int })(nil))
+	tReserved3 = bootstrapType("_reserved3", (*struct{ r3 int })(nil))
+	tReserved2 = bootstrapType("_reserved2", (*struct{ r2 int })(nil))
 	tReserved1 = bootstrapType("_reserved1", (*struct{ r1 int })(nil))
 )
 

package/bin/go/src/encoding/hex/hex.go

@@ -85,10 +85,10 @@ func DecodedLen(x int) int { return x / 2 }
 // If the input is malformed, Decode returns the number
 // of bytes decoded before the error.
 func Decode(dst, src []byte) (int, error) {
-	i, j := 0, 1
-	for ; j < len(src); j += 2 {
-		p := src[j-1]
-		q := src[j]
+	i, j := 0, 0
+	for ; j < len(src)-1; j += 2 {
+		p := src[j]
+		q := src[j+1]
 
 		a := reverseHexTable[p]
 		b := reverseHexTable[q]
@@ -104,8 +104,8 @@ func Decode(dst, src []byte) (int, error) {
 	if len(src)%2 == 1 {
 		// Check for invalid char before reporting bad length,
 		// since the invalid char (if present) is an earlier problem.
-		if reverseHexTable[src[j-1]] > 0x0f {
-			return i, InvalidByteError(src[j-1])
+		if reverseHexTable[src[j]] > 0x0f {
+			return i, InvalidByteError(src[j])
 		}
 		return i, ErrLength
 	}

package/bin/go/src/encoding/json/decode.go

@@ -19,7 +19,6 @@ import (
 	"unicode"
 	"unicode/utf16"
 	"unicode/utf8"
-	_ "unsafe" // for linkname
 )
 
 // Unmarshal parses the JSON-encoded data and stores the result
@@ -62,8 +61,10 @@ import (
 //   - map[string]any, for JSON objects
 //   - nil for JSON null
 //
-// To unmarshal a JSON array into a slice, Unmarshal resets the slice length
-// to zero and then appends each element to the slice.
+// To unmarshal a JSON array into a slice, Unmarshal decodes each JSON array
+// element into the corresponding slice element, reusing existing slice
+// elements in-place. The slice grows to accommodate additional elements,
+// or is truncated if the JSON array is shorter.
 // As a special case, to unmarshal an empty JSON array into a slice,
 // Unmarshal replaces the slice with a new empty slice.
 //

package/bin/go/src/encoding/json/encode.go

@@ -26,7 +26,7 @@
 //
 // Due to the Go Backwards Compatibility promise (https://go.dev/doc/go1compat)
 // there are a number of behaviors this package exhibits that may cause
-// interopability issues, but cannot be changed. In particular the following
+// interoperability issues, but cannot be changed. In particular the following
 // parsing behaviors may cause issues:
 //
 //   - If a JSON object contains duplicate keys, keys are processed in the order
@@ -58,7 +58,6 @@ import (
 	"sync"
 	"unicode"
 	"unicode/utf8"
-	_ "unsafe" // for linkname
 )
 
 // Marshal returns the JSON encoding of v.