Go 1.26.2

VERSION

@@ -1,2 +1,2 @@
-go1.26.1
-time 2026-03-05T20:45:11Z
+go1.26.2
+time 2026-03-27T21:58:29Z

doc/godebug.md

@@ -133,9 +133,7 @@ are also treated as invalid.
 The defaults that will be compiled into a main package
 are reported by the command:
 
-{{raw `
 	go list -f '{{.DefaultGODEBUG}}' my/main/package
-`}}
 
 Only differences from the base Go toolchain defaults are reported.
 

src/archive/tar/format.go

@@ -147,6 +147,12 @@ const (
 	// Max length of a special file (PAX header, GNU long name or link).
 	// This matches the limit used by libarchive.
 	maxSpecialFileSize = 1 << 20
+
+	// Maximum number of sparse file entries.
+	// We should never actually hit this limit
+	// (every sparse encoding will first be limited by maxSpecialFileSize),
+	// but this adds an additional layer of defense.
+	maxSparseFileEntries = 1 << 20
 )
 
 // blockPadding computes the number of bytes needed to pad offset up to the

src/archive/tar/reader.go

@@ -490,7 +490,8 @@ func (tr *Reader) readOldGNUSparseMap(hdr *Header, blk *block) (sparseDatas, err
 	}
 	s := blk.toGNU().sparse()
 	spd := make(sparseDatas, 0, s.maxEntries())
-	for {
+	totalSize := len(s)
+	for totalSize < maxSpecialFileSize {
 		for i := 0; i < s.maxEntries(); i++ {
 			// This termination condition is identical to GNU and BSD tar.
 			if s.entry(i).offset()[0] == 0x00 {
@@ -501,7 +502,11 @@ func (tr *Reader) readOldGNUSparseMap(hdr *Header, blk *block) (sparseDatas, err
 			if p.err != nil {
 				return nil, p.err
 			}
-			spd = append(spd, sparseEntry{Offset: offset, Length: length})
+			var err error
+			spd, err = appendSparseEntry(spd, sparseEntry{Offset: offset, Length: length})
+			if err != nil {
+				return nil, err
+			}
 		}
 
 		if s.isExtended()[0] > 0 {
@@ -510,10 +515,12 @@ func (tr *Reader) readOldGNUSparseMap(hdr *Header, blk *block) (sparseDatas, err
 				return nil, err
 			}
 			s = blk.toSparse()
+			totalSize += len(s)
 			continue
 		}
 		return spd, nil // Done
 	}
+	return nil, errSparseTooLong
 }
 
 // readGNUSparseMap1x0 reads the sparse map as stored in GNU's PAX sparse format
@@ -586,7 +593,10 @@ func readGNUSparseMap1x0(r io.Reader) (sparseDatas, error) {
 		if err1 != nil || err2 != nil {
 			return nil, ErrHeader
 		}
-		spd = append(spd, sparseEntry{Offset: offset, Length: length})
+		spd, err = appendSparseEntry(spd, sparseEntry{Offset: offset, Length: length})
+		if err != nil {
+			return nil, err
+		}
 	}
 	return spd, nil
 }
@@ -620,12 +630,22 @@ func readGNUSparseMap0x1(paxHdrs map[string]string) (sparseDatas, error) {
 		if err1 != nil || err2 != nil {
 			return nil, ErrHeader
 		}
-		spd = append(spd, sparseEntry{Offset: offset, Length: length})
+		spd, err = appendSparseEntry(spd, sparseEntry{Offset: offset, Length: length})
+		if err != nil {
+			return nil, err
+		}
 		sparseMap = sparseMap[2:]
 	}
 	return spd, nil
 }
 
+func appendSparseEntry(spd sparseDatas, ent sparseEntry) (sparseDatas, error) {
+	if len(spd) >= maxSparseFileEntries {
+		return nil, errSparseTooLong
+	}
+	return append(spd, ent), nil
+}
+
 // Read reads from the current file in the tar archive.
 // It returns (0, io.EOF) when it reaches the end of that file,
 // until [Next] is called to advance to the next file.

src/archive/tar/reader_test.go

@@ -1145,6 +1145,17 @@ func TestReadOldGNUSparseMap(t *testing.T) {
 		input: makeInput(FormatGNU, "",
 			makeSparseStrings(sparseDatas{{10 << 30, 512}, {20 << 30, 512}})...),
 		wantMap: sparseDatas{{10 << 30, 512}, {20 << 30, 512}},
+	}, {
+		input: makeInput(FormatGNU, "",
+			makeSparseStrings(func() sparseDatas {
+				var datas sparseDatas
+				// This is more than enough entries to exceed our limit.
+				for i := range int64(1 << 20) {
+					datas = append(datas, sparseEntry{i * 2, (i * 2) + 1})
+				}
+				return datas
+			}())...),
+		wantErr: errSparseTooLong,
 	}}
 
 	for i, v := range vectors {

src/builtin/builtin.go

@@ -122,6 +122,10 @@ type Type int
 // invocation.
 type Type1 int
 
+// TypeOrExpr is here for the purposes of documentation only. It is a stand-in
+// for either a Go type or an expression.
+type TypeOrExpr int
+
 // IntegerType is here for the purposes of documentation only. It is a stand-in
 // for any integer type: int, uint, int8 etc.
 type IntegerType int
@@ -220,10 +224,15 @@ func max[T cmp.Ordered](x T, y ...T) T
 // min will return NaN.
 func min[T cmp.Ordered](x T, y ...T) T
 
-// The new built-in function allocates memory. The first argument is a type,
-// not a value, and the value returned is a pointer to a newly
-// allocated zero value of that type.
-func new(Type) *Type
+// The built-in function new allocates a new, initialized variable and returns
+// a pointer to it. It accepts a single argument, which may be either a type
+// or an expression.
+// If the argument is a type T, then new(T) allocates a variable of type T
+// initialized to its zero value.
+// Otherwise, the argument is an expression x and new(x) allocates a variable
+// of the type of x initialized to the value of x. If that value is an untyped
+// constant, it is first implicitly converted to its default type.
+func new(TypeOrExpr) *Type
 
 // The complex built-in function constructs a complex value from two
 // floating-point values. The real and imaginary parts must be of the same

src/cmd/compile/internal/bloop/bloop.go

@@ -144,7 +144,7 @@ func preserveStmt(curFn *ir.Func, stmt ir.Node) (ret ir.Node) {
 		if name != nil {
 			debugName(name, n.Pos())
 			ret = keepAliveAt([]ir.Node{name}, n)
-		} else if deref := n.X.(*ir.StarExpr); deref != nil {
+		} else if deref, ok := n.X.(*ir.StarExpr); ok && deref != nil {
 			ret = keepAliveAt([]ir.Node{deref}, n)
 			if base.Flag.LowerM > 1 {
 				base.WarnfAt(n.Pos(), "dereference will be kept alive")
@@ -159,7 +159,7 @@ func preserveStmt(curFn *ir.Func, stmt ir.Node) (ret ir.Node) {
 			if name != nil {
 				debugName(name, n.Pos())
 				ns = append(ns, name)
-			} else if deref := lhs.(*ir.StarExpr); deref != nil {
+			} else if deref, ok := lhs.(*ir.StarExpr); ok && deref != nil {
 				ns = append(ns, deref)
 				if base.Flag.LowerM > 1 {
 					base.WarnfAt(n.Pos(), "dereference will be kept alive")
@@ -174,7 +174,7 @@ func preserveStmt(curFn *ir.Func, stmt ir.Node) (ret ir.Node) {
 		if name != nil {
 			debugName(name, n.Pos())
 			ret = keepAliveAt([]ir.Node{name}, n)
-		} else if deref := n.X.(*ir.StarExpr); deref != nil {
+		} else if deref, ok := n.X.(*ir.StarExpr); ok && deref != nil {
 			ret = keepAliveAt([]ir.Node{deref}, n)
 			if base.Flag.LowerM > 1 {
 				base.WarnfAt(n.Pos(), "dereference will be kept alive")

src/cmd/compile/internal/ssa/_gen/dec.rules

@@ -101,8 +101,7 @@
 
 (IMake _typ (StructMake ___)) => imakeOfStructMake(v)
 (StructSelect (IData x)) && v.Type.Size() > 0 => (IData x)
-(StructSelect (IData x)) && v.Type.Size() == 0 && v.Type.IsStruct() => (StructMake)
-(StructSelect (IData x)) && v.Type.Size() == 0 && v.Type.IsArray() => (ArrayMake0)
+(StructSelect (IData x)) && v.Type.Size() == 0 => (Empty)
 
 (StructSelect [i] x:(StructMake ___)) => x.Args[i]
 

src/cmd/compile/internal/ssa/_gen/generic.rules

@@ -941,7 +941,7 @@
 
 // struct operations
 (StructSelect [i] x:(StructMake ___)) => x.Args[i]
-(Load <t> _ _) && t.IsStruct() && CanSSA(t) && !t.IsSIMD() => rewriteStructLoad(v)
+(Load <t> _ _) && t.IsStruct() && t.Size() > 0 && CanSSA(t) && !t.IsSIMD() => rewriteStructLoad(v)
 (Store _ (StructMake ___) _) => rewriteStructStore(v)
 
 (StructSelect [i] x:(Load <t> ptr mem)) && !CanSSA(t) =>
@@ -950,8 +950,7 @@
 // Putting struct{*byte} and similar into direct interfaces.
 (IMake _typ (StructMake ___)) => imakeOfStructMake(v)
 (StructSelect (IData x)) && v.Type.Size() > 0 => (IData x)
-(StructSelect (IData x)) && v.Type.Size() == 0 && v.Type.IsStruct() => (StructMake)
-(StructSelect (IData x)) && v.Type.Size() == 0 && v.Type.IsArray() => (ArrayMake0)
+(StructSelect (IData x)) && v.Type.Size() == 0 => (Empty)
 
 // un-SSAable values use mem->mem copies
 (Store {t} dst (Load src mem) mem) && !CanSSA(t) =>
@@ -962,19 +961,19 @@
 // array ops
 (ArraySelect (ArrayMake1 x)) => x
 
-(Load <t> _ _) && t.IsArray() && t.NumElem() == 0 =>
-  (ArrayMake0)
-
 (Load <t> ptr mem) && t.IsArray() && t.NumElem() == 1 && CanSSA(t) =>
   (ArrayMake1 (Load <t.Elem()> ptr mem))
 
-(Store _ (ArrayMake0) mem) => mem
 (Store dst (ArrayMake1 e) mem) => (Store {e.Type} dst e mem)
 
 // Putting [1]*byte and similar into direct interfaces.
 (IMake _typ (ArrayMake1 val)) => (IMake _typ val)
 (ArraySelect [0] (IData x)) => (IData x)
 
+// zero-sized values.
+(Load <t> _ _) && t.Size() == 0 => (Empty)
+(Store _ (Empty) mem) => mem
+
 // string ops
 // Decomposing StringMake and lowering of StringPtr and StringLen
 // happens in a later pass, dec, so that these operations are available

src/cmd/compile/internal/ssa/_gen/genericOps.go

@@ -537,12 +537,11 @@ var genericOps = []opData{
 	{name: "IData", argLength: 1},                // arg0=interface, returns data field
 
 	// Structs
-	{name: "StructMake", argLength: -1},                // args...=field0..n-1. Returns struct with n fields.
+	{name: "StructMake", argLength: -1},                // args...=field0..n-1. Returns struct with n fields. Must have >0 size (use Empty otherwise).
 	{name: "StructSelect", argLength: 1, aux: "Int64"}, // arg0=struct, auxint=field index.  Returns the auxint'th field.
 
 	// Arrays
-	{name: "ArrayMake0"},                              // Returns array with 0 elements
-	{name: "ArrayMake1", argLength: 1},                // Returns array with 1 element
+	{name: "ArrayMake1", argLength: 1},                // Returns array with 1 element. Use Empty if the element is zero-sized.
 	{name: "ArraySelect", argLength: 1, aux: "Int64"}, // arg0=array, auxint=index. Returns a[i].
 
 	// Spill&restore ops for the register allocator. These are
@@ -682,6 +681,9 @@ var genericOps = []opData{
 	// Helper instruction which is semantically equivalent to calling runtime.memequal, but some targets may prefer to custom lower it later, e.g. for specific constant sizes.
 	{name: "MemEq", argLength: 4, commutative: true, typ: "Bool"}, // arg0=ptr0, arg1=ptr1, arg2=size, arg3=memory.
 
+	// Value of a zero-sized type.
+	{name: "Empty", argLength: 0},
+
 	// SIMD
 	{name: "ZeroSIMD", argLength: 0}, // zero value of a vector
 

src/cmd/compile/internal/ssa/check.go

@@ -274,6 +274,10 @@ func checkFunc(f *Func) {
 				}
 			}
 
+			if (v.Op == OpStructMake || v.Op == OpArrayMake1) && v.Type.Size() == 0 {
+				f.Fatalf("zero-sized Make; use Empty instead %v", v)
+			}
+
 			if f.RegAlloc != nil && f.Config.SoftFloat && v.Type.IsFloat() {
 				f.Fatalf("unexpected floating-point type %v", v.LongString())
 			}

src/cmd/compile/internal/ssa/copyelim.go

@@ -105,11 +105,7 @@ func phielim(f *Func) {
 				// This is an early place in SSA where all values are examined.
 				// Rewrite all 0-sized Go values to remove accessors, dereferences, loads, etc.
 				if t := v.Type; (t.IsStruct() || t.IsArray()) && t.Size() == 0 {
-					if t.IsStruct() {
-						v.reset(OpStructMake)
-					} else {
-						v.reset(OpArrayMake0)
-					}
+					v.reset(OpEmpty)
 				}
 				// Modify all values so no arg (including args
 				// of OpCopy) is a copy.

src/cmd/compile/internal/ssa/decompose.go

@@ -266,7 +266,7 @@ func decomposeUser(f *Func) {
 // returned.
 func decomposeUserArrayInto(f *Func, name *LocalSlot, slots []*LocalSlot) []*LocalSlot {
 	t := name.Type
-	if t.NumElem() == 0 {
+	if t.Size() == 0 {
 		// TODO(khr): Not sure what to do here.  Probably nothing.
 		// Names for empty arrays aren't important.
 		return slots
@@ -362,6 +362,10 @@ func decomposeUserPhi(v *Value) {
 // and then recursively decomposes the phis for each field.
 func decomposeStructPhi(v *Value) {
 	t := v.Type
+	if t.Size() == 0 {
+		v.reset(OpEmpty)
+		return
+	}
 	n := t.NumFields()
 	fields := make([]*Value, 0, MaxStruct)
 	for i := 0; i < n; i++ {
@@ -385,8 +389,8 @@ func decomposeStructPhi(v *Value) {
 // and then recursively decomposes the element phi.
 func decomposeArrayPhi(v *Value) {
 	t := v.Type
-	if t.NumElem() == 0 {
-		v.reset(OpArrayMake0)
+	if t.Size() == 0 {
+		v.reset(OpEmpty)
 		return
 	}
 	if t.NumElem() != 1 {

src/cmd/compile/internal/ssa/expand_calls.go

@@ -508,13 +508,7 @@ func (x *expandState) rewriteSelectOrArg(pos src.XPos, b *Block, container, a, m
 
 	if at.Size() == 0 {
 		// For consistency, create these values even though they'll ultimately be unused
-		if at.IsArray() {
-			return makeOf(a, OpArrayMake0, nil)
-		}
-		if at.IsStruct() {
-			return makeOf(a, OpStructMake, nil)
-		}
-		return a
+		return makeOf(a, OpEmpty, nil)
 	}
 
 	sk := selKey{from: container, size: 0, offsetOrIndex: rc.storeOffset, typ: at}