Merge pull request #54 from golang/master

[pull] master from golang:master

Author: pull[bot]

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

@@ -3573,16 +3573,14 @@ func (s *state) exprCheckPtr(n ir.Node, checkPtrOK bool) *ssa.Value {
 				bound := n.X.Type().NumElem()
 				a := s.expr(n.X)
 				i := s.expr(n.Index)
+				len := s.constInt(types.Types[types.TINT], bound)
 				if bound == 0 {
-					// Bounds check will never succeed.  Might as well
-					// use constants for the bounds check.
-					z := s.constInt(types.Types[types.TINT], 0)
-					s.boundsCheck(z, z, ssa.BoundsIndex, false)
+					// Bounds check will never succeed.
+					s.boundsCheck(i, len, ssa.BoundsIndex, false)
 					// The return value won't be live. In case bounds checks
 					// are turned off, load from (*T)(nil) to cause a segfault.
 					return s.load(n.Type(), s.constNil(n.Type().PtrTo()))
 				}
-				len := s.constInt(types.Types[types.TINT], bound)
 				s.boundsCheck(i, len, ssa.BoundsIndex, n.Bounded()) // checks i == 0
 				return s.newValue1I(ssa.OpArraySelect, n.Type(), 0, a)
 			}
@@ -4545,12 +4543,21 @@ func (s *state) assignWhichMayOverlap(left ir.Node, right *ssa.Value, deref bool
 
 			i := s.expr(left.Index) // index
 			if n == 0 {
+				_ = s.expr(left.X) // Evaluating left.X for any side-effects.
 				// The bounds check must fail.  Might as well
 				// ignore the actual index and just use zeros.
 				z := s.constInt(types.Types[types.TINT], 0)
 				s.boundsCheck(z, z, ssa.BoundsIndex, false)
 				return
 			}
+			if t.Size() == 0 {
+				_ = s.expr(left.X) // Evaluating left.X for any side-effects.
+				// Generate bounds check for left, since this can happen
+				// for 0-size assignment case, see issue #79236.
+				len := s.constInt(types.Types[types.TINT], n)
+				s.boundsCheck(i, len, ssa.BoundsIndex, false)
+				return
+			}
 			if n != 1 {
 				// This can happen in weird, always-panics cases, like:
 				//     var x [0][2]int
@@ -4560,11 +4567,8 @@ func (s *state) assignWhichMayOverlap(left ir.Node, right *ssa.Value, deref bool
 				// they are somewhere inside an outer [0].
 				// We can ignore the actual assignment, it is dynamically
 				// unreachable. See issue 77635.
-				return
-			}
-			if t.Size() == 0 {
-				len := s.constInt(types.Types[types.TINT], n)
-				s.boundsCheck(i, len, ssa.BoundsIndex, false)
+				// Still, evaluating left.X for any side-effects.
+				_ = s.expr(left.X)
 				return
 			}
 
@@ -5276,6 +5280,7 @@ func (s *state) addr(n ir.Node) *ssa.Value {
 		// &x[i], which will always panic when evaluated.
 		// We just return something reasonable in this case.
 		// It will be dynamically unreachable. See issue 77635.
+		s.boundsCheckArrayIndex(n)
 		return s.newValue1A(ssa.OpAddr, n.Type().PtrTo(), ir.Syms.Zerobase, s.sb)
 	}
 
@@ -5458,6 +5463,21 @@ func (s *state) nilCheck(ptr *ssa.Value) *ssa.Value {
 	return s.newValue2(ssa.OpNilCheck, ptr.Type, ptr, s.mem())
 }
 
+// boundsCheckArrayIndex generates bounds checking code for array indexing operations.
+func (s *state) boundsCheckArrayIndex(n ir.Node) {
+	if n.Op() != ir.OINDEX {
+		return
+	}
+	nn := n.(*ir.IndexExpr)
+	typ := nn.X.Type()
+	if typ.IsArray() {
+		_ = s.expr(nn.X) // for side effects
+		idx := s.expr(nn.Index)
+		len := s.constInt(types.Types[types.TINT], typ.NumElem())
+		s.boundsCheck(idx, len, ssa.BoundsIndex, nn.Bounded())
+	}
+}
+
 // boundsCheck generates bounds checking code. Checks if 0 <= idx <[=] len, branches to exit if not.
 // Starts a new block on return.
 // On input, len must be converted to full int width and be nonnegative.

src/cmd/go/internal/base/base.go

@@ -175,6 +175,8 @@ func Fatal(err error) {
 var exitStatus = 0
 var exitMu sync.Mutex
 
+// SetExitStatus sets exit status to n if
+// n is higher than the current exit status.
 func SetExitStatus(n int) {
 	exitMu.Lock()
 	if exitStatus < n {
@@ -183,6 +185,7 @@ func SetExitStatus(n int) {
 	exitMu.Unlock()
 }
 
+// GetExitStatus reports the current exit status.
 func GetExitStatus() int {
 	return exitStatus
 }

src/cmd/go/internal/tool/tool.go

@@ -424,7 +424,13 @@ func runBuiltTool(toolName string, env, cmdline []string) error {
 			fmt.Fprintf(os.Stderr, "go tool %s: %s\n", toolName, err)
 		}
 		if ok {
-			base.SetExitStatus(e.ExitCode())
+			n := e.ExitCode()
+			if n == -1 {
+				// If the tool was terminated by a signal,
+				// set a non-zero exit status. See go.dev/issue/79540.
+				n = 1
+			}
+			base.SetExitStatus(n)
 		} else {
 			base.SetExitStatus(1)
 		}

src/cmd/go/testdata/script/tool_signal_exit.txt

@@ -0,0 +1,29 @@
+[short] skip 'runs go build'
+[GOOS:plan9] skip 'signals differ on Plan 9'
+[GOOS:windows] skip 'os.Interrupt is not implemented on Windows'
+
+! go tool interrupter
+stderr 'go tool interrupter: signal: interrupt'
+
+-- go.mod --
+module example.com/interrupter
+
+go 1.26.0
+
+tool example.com/interrupter/cmd/interrupter
+
+-- cmd/interrupter/main.go --
+package main
+
+import "os"
+
+func main() {
+	p, err := os.FindProcess(os.Getpid())
+	if err != nil {
+		panic(err)
+	}
+	if err := p.Signal(os.Interrupt); err != nil {
+		panic(err)
+	}
+	select {}
+}

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
 }
 

src/debug/dwarf/entry_test.go

@@ -267,9 +267,10 @@ func Test64Bit(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		data, err := New(nil, nil, nil, test.info, nil, nil, nil, nil)
+		data, err := New([]byte{0}, nil, nil, test.info, nil, nil, nil, nil)
 		if err != nil {
 			t.Errorf("%s: %v", test.name, err)
+			continue
 		}
 
 		r := data.Reader()
@@ -445,12 +446,17 @@ func TestIssue51758(t *testing.T) {
 }
 
 func TestIssue52045(t *testing.T) {
-	var abbrev, aranges, frame, line, pubnames, ranges, str []byte
+	var aranges, frame, line, pubnames, ranges, str []byte
+	abbrev := []byte{0}
 	info := []byte{0x7, 0x0, 0x0, 0x0, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}
 
 	// A hand-crafted input corresponding to a minimal-size
 	// .debug_info (header only, no DIEs) and an empty abbrev table.
-	data0, _ := New(abbrev, aranges, frame, info, line, pubnames, ranges, str)
+	data0, err := New(abbrev, aranges, frame, info, line, pubnames, ranges, str)
+	if err != nil {
+		t.Fatal(err)
+	}
+
 	reader0 := data0.Reader()
 	entry0, _ := reader0.SeekPC(0x0)
 	// main goal is to make sure we can get here without crashing

src/debug/dwarf/line_test.go

@@ -431,32 +431,3 @@ func TestPathJoin(t *testing.T) {
 		}
 	}
 }
-
-func TestPathLineReaderMalformed(t *testing.T) {
-	// This test case drawn from issue #52354. What's happening
-	// here is that the stmtList attribute in the compilation
-	// unit is malformed (negative).
-	var aranges, frame, pubnames, ranges, str []byte
-	abbrev := []byte{0x10, 0x20, 0x20, 0x20, 0x21, 0x20, 0x10, 0x21, 0x61,
-		0x0, 0x0, 0xff, 0x20, 0xff, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-		0x20, 0x20, 0x20, 0x20, 0x20, 0x20}
-	info := []byte{0x0, 0x0, 0x0, 0x9, 0x0, 0x2, 0x0, 0x0, 0x0, 0x0,
-		0x20, 0x10, 0x10}
-	line := []byte{0x20}
-	Data0, err := New(abbrev, aranges, frame, info, line, pubnames, ranges, str)
-	if err != nil {
-		t.Fatalf("error unexpected: %v", err)
-	}
-	Reader0 := Data0.Reader()
-	Entry0, err := Reader0.Next()
-	if err != nil {
-		t.Fatalf("error unexpected: %v", err)
-	}
-	LineReader0, err := Data0.LineReader(Entry0)
-	if err == nil {
-		t.Fatalf("expected error")
-	}
-	if LineReader0 != nil {
-		t.Fatalf("expected nil line reader")
-	}
-}

src/debug/elf/file.go

@@ -460,7 +460,7 @@ func NewFile(r io.ReaderAt) (*File, error) {
 		// section header at index 0.
 		if shstrndx == int(SHN_XINDEX) {
 			shstrndx = int(link)
-			if shstrndx < int(SHN_LORESERVE) {
+			if shstrndx < int(SHN_LORESERVE) || shstrndx >= shnum {
 				return nil, &FormatError{shoff, "invalid ELF shstrndx contained in sh_link", shstrndx}
 			}
 		}

src/encoding/gob/decode.go

@@ -594,6 +594,12 @@ 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() {
+		// This is a map, not a slice, but capping the
+		// size works either way.
+		n = saferio.SliceCapWithSize(uint64(mtyp.Elem().Size()), uint64(n))
+		if n < 0 {
+			n = 1
+		}
 		value.Set(reflect.MakeMapWithSize(mtyp, n))
 	}
 	keyIsPtr := mtyp.Key().Kind() == reflect.Pointer

src/runtime/testdata/testprog/gc.go

@@ -396,7 +396,7 @@ func gcMemoryLimit(gcPercent int) {
 		// should do considerably better than this bound.
 		bound := int64(myLimit + 16<<20)
 		if runtime.GOOS == "darwin" {
-			bound += 24 << 20 // Be more lax on Darwin, see issue 73136.
+			bound += 48 << 20 // Be more lax on Darwin, see issue 73136.
 		}
 		start := time.Now()
 		for time.Since(start) < 200*time.Millisecond {