log/slog: add multiple handlers support for logger

api/next/65954.txt

@@ -0,0 +1 @@
+pkg log/slog, func MultiHandler(...Handler) Handler #65954

doc/go_mem.html

@@ -231,7 +231,7 @@ <h2 id="restrictions">Implementation Restrictions for Programs Containing Data R
 
 <p>
 A read of an array, struct, or complex number
-may by implemented as a read of each individual sub-value
+may be implemented as a read of each individual sub-value
 (array element, struct field, or real/imaginary component),
 in any order.
 Similarly, a write of an array, struct, or complex number

doc/next/6-stdlib/99-minor/log/slog/65954.md

@@ -0,0 +1,6 @@
+The [`MultiHandler`](/pkg/log/slog#MultiHandler) function returns a handler that
+invokes all the given Handlers.
+Its `Enable` method reports whether any of the handlers' `Enabled` methods
+return true.
+Its `Handle`, `WithAttr` and `WithGroup` methods call the corresponding method
+on each of the enabled handlers.

doc/next/7-ports.md

@@ -1,2 +1,6 @@
 ## Ports {#ports}
 
+### Windows
+
+<!-- go.dev/issue/71671 -->
+As [announced](/doc/go1.25#windows) in the Go 1.25 release notes, the [broken](/doc/go1.24#windows) 32-bit windows/arm port (`GOOS=windows` `GOARCH=arm`) is removed.

src/cmd/asm/internal/arch/loong64.go

@@ -23,18 +23,6 @@ func jumpLoong64(word string) bool {
 	return false
 }
 
-// IsLoong64MUL reports whether the op (as defined by an loong64.A* constant) is
-// one of the MUL/DIV/REM instructions that require special handling.
-func IsLoong64MUL(op obj.As) bool {
-	switch op {
-	case loong64.AMUL, loong64.AMULU, loong64.AMULV, loong64.AMULVU,
-		loong64.ADIV, loong64.ADIVU, loong64.ADIVV, loong64.ADIVVU,
-		loong64.AREM, loong64.AREMU, loong64.AREMV, loong64.AREMVU:
-		return true
-	}
-	return false
-}
-
 // IsLoong64RDTIME reports whether the op (as defined by an loong64.A*
 // constant) is one of the RDTIMELW/RDTIMEHW/RDTIMED instructions that
 // require special handling.

src/cmd/asm/internal/asm/asm.go

@@ -974,14 +974,6 @@ func (p *Parser) getConstant(prog *obj.Prog, op obj.As, addr *obj.Addr) int64 {
 	return addr.Offset
 }
 
-// getImmediate checks that addr represents an immediate constant and returns its value.
-func (p *Parser) getImmediate(prog *obj.Prog, op obj.As, addr *obj.Addr) int64 {
-	if addr.Type != obj.TYPE_CONST || addr.Name != 0 || addr.Reg != 0 || addr.Index != 0 {
-		p.errorf("%s: expected immediate constant; found %s", op, obj.Dconv(prog, addr))
-	}
-	return addr.Offset
-}
-
 // getRegister checks that addr represents a register and returns its value.
 func (p *Parser) getRegister(prog *obj.Prog, op obj.As, addr *obj.Addr) int16 {
 	if addr.Type != obj.TYPE_REG || addr.Offset != 0 || addr.Name != 0 || addr.Index != 0 {

src/cmd/asm/internal/asm/testdata/loong64enc1.s

@@ -376,6 +376,10 @@ lable2:
 	FTINTRNEVF	F0, F2		// 02e41a01
 	FTINTRNEVD	F0, F2		// 02e81a01
 
+	// FSEL instruction
+	FSEL	FCC0, F1, F2, F3	// 4304000d
+	FSEL	FCC1, F1, F2		// 4284000d
+
 	// LDX.{B,BU,H,HU,W,WU,D} instructions
 	MOVB		(R14)(R13), R12	// cc350038
 	MOVBU		(R14)(R13), R12	// cc352038
@@ -510,6 +514,16 @@ lable2:
 	VMOVQ		V3.W[1], V7.W4  // 67e4f772
 	VMOVQ		V4.V[0], V6.V2  // 86f0f772
 
+	// Load data from memory and broadcast to each element of a vector register: VMOVQ    offset(Rj), <Vd>.<T>
+	VMOVQ		(R4), V0.B16	// 80008030
+	VMOVQ		1(R4), V1.H8	// 81044030
+	VMOVQ		2(R4), V2.W4	// 82082030
+	VMOVQ		3(R4), V3.V2	// 830c1030
+	XVMOVQ		(R4), X0.B32	// 80008032
+	XVMOVQ		1(R4), X1.H16	// 81044032
+	XVMOVQ		2(R4), X2.W8	// 82082032
+	XVMOVQ		3(R4), X3.V4	// 830c1032
+
 	// VSEQ{B,H,W,V}, XVSEQ{B,H,W,V} instruction
 	VSEQB		V1, V2, V3      // 43040070
 	VSEQH		V1, V2, V3      // 43840070
@@ -1035,3 +1049,58 @@ lable2:
 	PRELD	(R4), $0		// 8000c02a
 	PRELD	-1(R4), $8		// 88fcff2a
 	PRELD	8(R4),  $31		// 9f20c02a
+
+	// [X]{VBITCLR/VBITSET/VBITREV}{B,H,W,V} instructions
+	VBITCLRB	V1, V2, V3	// 43040c71
+	VBITCLRH	V1, V2, V3	// 43840c71
+	VBITCLRW	V1, V2, V3	// 43040d71
+	VBITCLRV	V1, V2, V3	// 43840d71
+	VBITSETB	V1, V2, V3	// 43040e71
+	VBITSETH	V1, V2, V3	// 43840e71
+	VBITSETW	V1, V2, V3	// 43040f71
+	VBITSETV	V1, V2, V3	// 43840f71
+	VBITREVB	V1, V2, V3	// 43041071
+	VBITREVH	V1, V2, V3	// 43841071
+	VBITREVW	V1, V2, V3	// 43041171
+	VBITREVV	V1, V2, V3	// 43841171
+	XVBITCLRB	X3, X2, X1	// 410c0c75
+	XVBITCLRH	X3, X2, X1	// 418c0c75
+	XVBITCLRW	X3, X2, X1	// 410c0d75
+	XVBITCLRV	X3, X2, X1	// 418c0d75
+	XVBITSETB	X3, X2, X1	// 410c0e75
+	XVBITSETH	X3, X2, X1	// 418c0e75
+	XVBITSETW	X3, X2, X1	// 410c0f75
+	XVBITSETV	X3, X2, X1	// 418c0f75
+	XVBITREVB	X3, X2, X1	// 410c1075
+	XVBITREVH	X3, X2, X1	// 418c1075
+	XVBITREVW	X3, X2, X1	// 410c1175
+	XVBITREVV	X3, X2, X1	// 418c1175
+	VBITCLRB	$7, V2, V3	// 433c1073
+	VBITCLRH	$15, V2, V3	// 437c1073
+	VBITCLRW	$31, V2, V3	// 43fc1073
+	VBITCLRV	$63, V2, V3	// 43fc1173
+	VBITSETB	$7, V2, V3	// 433c1473
+	VBITSETH	$15, V2, V3	// 437c1473
+	VBITSETW	$31, V2, V3	// 43fc1473
+	VBITSETV	$63, V2, V3	// 43fc1573
+	VBITREVB	$7, V2, V3	// 433c1873
+	VBITREVH	$15, V2, V3	// 437c1873
+	VBITREVW	$31, V2, V3	// 43fc1873
+	VBITREVV	$63, V2, V3	// 43fc1973
+	XVBITCLRB	$7, X2, X1	// 413c1077
+	XVBITCLRH	$15, X2, X1	// 417c1077
+	XVBITCLRW	$31, X2, X1	// 41fc1077
+	XVBITCLRV	$63, X2, X1	// 41fc1177
+	XVBITSETB	$7, X2, X1	// 413c1477
+	XVBITSETH	$15, X2, X1	// 417c1477
+	XVBITSETW	$31, X2, X1	// 41fc1477
+	XVBITSETV	$63, X2, X1	// 41fc1577
+	XVBITREVB	$7, X2, X1	// 413c1877
+	XVBITREVH	$15, X2, X1	// 417c1877
+	XVBITREVW	$31, X2, X1	// 41fc1877
+	XVBITREVV	$63, X2, X1	// 41fc1977
+
+	// ALSL{W/WU/D}
+	ALSLW		$4, R4, R5, R6	// 86940500
+	ALSLWU		$4, R4, R5, R6	// 86940700
+	ALSLV		$4, R4, R5, R6	// 86942d00

src/cmd/cgo/internal/test/test.go

@@ -245,7 +245,7 @@ static void *thread(void *p) {
 	return NULL;
 }
 void testSendSIG() {
-	const int N = 20;
+	enum { N = 20 };
 	int i;
 	pthread_t tid[N];
 	for (i = 0; i < N; i++) {

src/cmd/compile/internal/importer/support.go

@@ -9,20 +9,14 @@ package importer
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/types2"
-	"fmt"
 	"go/token"
 	"internal/pkgbits"
-	"sync"
 )
 
 func assert(p bool) {
 	base.Assert(p)
 }
 
-func errorf(format string, args ...interface{}) {
-	panic(fmt.Sprintf(format, args...))
-}
-
 const deltaNewFile = -64 // see cmd/compile/internal/gc/bexport.go
 
 // Synthesize a token.Pos
@@ -31,108 +25,6 @@ type fakeFileSet struct {
 	files map[string]*token.File
 }
 
-func (s *fakeFileSet) pos(file string, line, column int) token.Pos {
-	// TODO(mdempsky): Make use of column.
-
-	// Since we don't know the set of needed file positions, we
-	// reserve maxlines positions per file.
-	const maxlines = 64 * 1024
-	f := s.files[file]
-	if f == nil {
-		f = s.fset.AddFile(file, -1, maxlines)
-		s.files[file] = f
-		// Allocate the fake linebreak indices on first use.
-		// TODO(adonovan): opt: save ~512KB using a more complex scheme?
-		fakeLinesOnce.Do(func() {
-			fakeLines = make([]int, maxlines)
-			for i := range fakeLines {
-				fakeLines[i] = i
-			}
-		})
-		f.SetLines(fakeLines)
-	}
-
-	if line > maxlines {
-		line = 1
-	}
-
-	// Treat the file as if it contained only newlines
-	// and column=1: use the line number as the offset.
-	return f.Pos(line - 1)
-}
-
-var (
-	fakeLines     []int
-	fakeLinesOnce sync.Once
-)
-
-func chanDir(d int) types2.ChanDir {
-	// tag values must match the constants in cmd/compile/internal/gc/go.go
-	switch d {
-	case 1 /* Crecv */ :
-		return types2.RecvOnly
-	case 2 /* Csend */ :
-		return types2.SendOnly
-	case 3 /* Cboth */ :
-		return types2.SendRecv
-	default:
-		errorf("unexpected channel dir %d", d)
-		return 0
-	}
-}
-
-var predeclared = []types2.Type{
-	// basic types
-	types2.Typ[types2.Bool],
-	types2.Typ[types2.Int],
-	types2.Typ[types2.Int8],
-	types2.Typ[types2.Int16],
-	types2.Typ[types2.Int32],
-	types2.Typ[types2.Int64],
-	types2.Typ[types2.Uint],
-	types2.Typ[types2.Uint8],
-	types2.Typ[types2.Uint16],
-	types2.Typ[types2.Uint32],
-	types2.Typ[types2.Uint64],
-	types2.Typ[types2.Uintptr],
-	types2.Typ[types2.Float32],
-	types2.Typ[types2.Float64],
-	types2.Typ[types2.Complex64],
-	types2.Typ[types2.Complex128],
-	types2.Typ[types2.String],
-
-	// basic type aliases
-	types2.Universe.Lookup("byte").Type(),
-	types2.Universe.Lookup("rune").Type(),
-
-	// error
-	types2.Universe.Lookup("error").Type(),
-
-	// untyped types
-	types2.Typ[types2.UntypedBool],
-	types2.Typ[types2.UntypedInt],
-	types2.Typ[types2.UntypedRune],
-	types2.Typ[types2.UntypedFloat],
-	types2.Typ[types2.UntypedComplex],
-	types2.Typ[types2.UntypedString],
-	types2.Typ[types2.UntypedNil],
-
-	// package unsafe
-	types2.Typ[types2.UnsafePointer],
-
-	// invalid type
-	types2.Typ[types2.Invalid], // only appears in packages with errors
-
-	// used internally by gc; never used by this package or in .a files
-	// not to be confused with the universe any
-	anyType{},
-
-	// comparable
-	types2.Universe.Lookup("comparable").Type(),
-
-	// "any" has special handling: see usage of predeclared.
-}
-
 type anyType struct{}
 
 func (t anyType) Underlying() types2.Type { return t }

src/cmd/compile/internal/inline/inl.go

@@ -1211,17 +1211,6 @@ func pruneUnusedAutos(ll []*ir.Name, vis *hairyVisitor) []*ir.Name {
 	return s
 }
 
-// numNonClosures returns the number of functions in list which are not closures.
-func numNonClosures(list []*ir.Func) int {
-	count := 0
-	for _, fn := range list {
-		if fn.OClosure == nil {
-			count++
-		}
-	}
-	return count
-}
-
 func doList(list []ir.Node, do func(ir.Node) bool) bool {
 	for _, x := range list {
 		if x != nil {

src/cmd/compile/internal/inline/inlheur/scoring.go

@@ -399,14 +399,6 @@ func LargestNegativeScoreAdjustment(fn *ir.Func, props *FuncProps) int {
 	return score
 }
 
-// LargestPositiveScoreAdjustment tries to estimate the largest possible
-// positive score adjustment that could be applied to a given callsite.
-// At the moment we don't have very many positive score adjustments, so
-// this is just hard-coded, not table-driven.
-func LargestPositiveScoreAdjustment(fn *ir.Func) int {
-	return adjValues[panicPathAdj] + adjValues[initFuncAdj]
-}
-
 // callSiteTab contains entries for each call in the function
 // currently being processed by InlineCalls; this variable will either
 // be set to 'cstabCache' below (for non-inlinable routines) or to the

src/cmd/compile/internal/ir/copy.go

@@ -32,12 +32,3 @@ func DeepCopy(pos src.XPos, n Node) Node {
 	}
 	return edit(n)
 }
-
-// DeepCopyList returns a list of deep copies (using DeepCopy) of the nodes in list.
-func DeepCopyList(pos src.XPos, list []Node) []Node {
-	var out []Node
-	for _, n := range list {
-		out = append(out, DeepCopy(pos, n))
-	}
-	return out
-}

src/cmd/compile/internal/ir/mini.go

@@ -34,15 +34,6 @@ type miniNode struct {
 	esc  uint16
 }
 
-// posOr returns pos if known, or else n.pos.
-// For use in DeepCopy.
-func (n *miniNode) posOr(pos src.XPos) src.XPos {
-	if pos.IsKnown() {
-		return pos
-	}
-	return n.pos
-}
-
 // op can be read, but not written.
 // An embedding implementation can provide a SetOp if desired.
 // (The panicking SetOp is with the other panics below.)

src/cmd/compile/internal/ir/visit.go

@@ -155,19 +155,6 @@ func Any(n Node, cond func(Node) bool) bool {
 	return do(n)
 }
 
-// AnyList calls Any(x, cond) for each node x in the list, in order.
-// If any call returns true, AnyList stops and returns true.
-// Otherwise, AnyList returns false after calling Any(x, cond)
-// for every x in the list.
-func AnyList(list Nodes, cond func(Node) bool) bool {
-	for _, x := range list {
-		if Any(x, cond) {
-			return true
-		}
-	}
-	return false
-}
-
 // EditChildren edits the child nodes of n, replacing each child x with edit(x).
 //
 // Note that EditChildren(n, edit) only calls edit(x) for n's immediate children.

src/cmd/compile/internal/noder/posmap.go

@@ -23,7 +23,6 @@ type poser interface{ Pos() syntax.Pos }
 type ender interface{ End() syntax.Pos }
 
 func (m *posMap) pos(p poser) src.XPos { return m.makeXPos(p.Pos()) }
-func (m *posMap) end(p ender) src.XPos { return m.makeXPos(p.End()) }
 
 func (m *posMap) makeXPos(pos syntax.Pos) src.XPos {
 	// Predeclared objects (e.g., the result parameter for error.Error)

src/cmd/compile/internal/noder/reader.go

@@ -3681,17 +3681,6 @@ func expandInline(fn *ir.Func, pri pkgReaderIndex) {
 	typecheck.Target.Funcs = typecheck.Target.Funcs[:topdcls]
 }
 
-// usedLocals returns a set of local variables that are used within body.
-func usedLocals(body []ir.Node) ir.NameSet {
-	var used ir.NameSet
-	ir.VisitList(body, func(n ir.Node) {
-		if n, ok := n.(*ir.Name); ok && n.Op() == ir.ONAME && n.Class == ir.PAUTO {
-			used.Add(n)
-		}
-	})
-	return used
-}
-
 // @@@ Method wrappers
 //
 // Here we handle constructing "method wrappers," alternative entry