Merge branch 'master' of github.com:kevin-valerio/go-arithmetic-panik

Author: kevin-valerio

src/cmd/compile/internal/dwarfgen/dwarf.go

@@ -248,11 +248,6 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir
 		if n.Class == ir.PPARAM || n.Class == ir.PPARAMOUT {
 			tag = dwarf.DW_TAG_formal_parameter
 		}
-		if n.Esc() == ir.EscHeap {
-			// The variable in question has been promoted to the heap.
-			// Its address is in n.Heapaddr.
-			// TODO(thanm): generate a better location expression
-		}
 		inlIndex := 0
 		if base.Flag.GenDwarfInl > 1 {
 			if n.InlFormal() || n.InlLocal() {
@@ -263,7 +258,7 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir
 			}
 		}
 		declpos := base.Ctxt.InnermostPos(n.Pos())
-		vars = append(vars, &dwarf.Var{
+		dvar := &dwarf.Var{
 			Name:          n.Sym().Name,
 			IsReturnValue: isReturnValue,
 			Tag:           tag,
@@ -277,8 +272,19 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir
 			ChildIndex:    -1,
 			DictIndex:     n.DictIndex,
 			ClosureOffset: closureOffset(n, closureVars),
-		})
-		// Record go type of to insure that it gets emitted by the linker.
+		}
+		if n.Esc() == ir.EscHeap {
+			if n.Heapaddr == nil {
+				base.Fatalf("invalid heap allocated var without Heapaddr")
+			}
+			debug := fn.DebugInfo.(*ssa.FuncDebug)
+			list := createHeapDerefLocationList(n, fnsym, debug.EntryID, ssa.FuncEnd.ID)
+			dvar.PutLocationList = func(listSym, startPC dwarf.Sym) {
+				debug.PutLocationList(list, base.Ctxt, listSym.(*obj.LSym), startPC.(*obj.LSym))
+			}
+		}
+		vars = append(vars, dvar)
+		// Record go type to ensure that it gets emitted by the linker.
 		fnsym.Func().RecordAutoType(reflectdata.TypeLinksym(n.Type()))
 	}
 
@@ -550,6 +556,29 @@ func createComplexVar(fnsym *obj.LSym, fn *ir.Func, varID ssa.VarID, closureVars
 	return dvar
 }
 
+// createHeapDerefLocationList creates a location list for a heap-escaped variable
+// that describes "dereference pointer at stack offset"
+func createHeapDerefLocationList(n *ir.Name, fnsym *obj.LSym, entryID, prologEndID ssa.ID) []byte {
+	// Get the stack offset where the heap pointer is stored
+	heapPtrOffset := n.Heapaddr.FrameOffset()
+	if base.Ctxt.Arch.FixedFrameSize == 0 {
+		heapPtrOffset -= int64(types.PtrSize)
+	}
+	if buildcfg.FramePointerEnabled {
+		heapPtrOffset -= int64(types.PtrSize)
+	}
+
+	// Create a location expression: DW_OP_fbreg <offset> DW_OP_deref
+	var locExpr []byte
+	var sizeIdx int
+	locExpr, sizeIdx = ssa.SetupLocList(base.Ctxt, entryID, locExpr, ssa.BlockStart.ID, ssa.FuncEnd.ID)
+	locExpr = append(locExpr, dwarf.DW_OP_fbreg)
+	locExpr = dwarf.AppendSleb128(locExpr, heapPtrOffset)
+	locExpr = append(locExpr, dwarf.DW_OP_deref)
+	base.Ctxt.Arch.ByteOrder.PutUint16(locExpr[sizeIdx:], uint16(len(locExpr)-sizeIdx-2))
+	return locExpr
+}
+
 // RecordFlags records the specified command-line flags to be placed
 // in the DWARF info.
 func RecordFlags(flags ...string) {

src/cmd/compile/internal/escape/escape.go

@@ -122,17 +122,24 @@ type escape struct {
 }
 
 func Funcs(all []*ir.Func) {
-	ir.VisitFuncsBottomUp(all, Batch)
+	// Make a cache of ir.ReassignOracles. The cache is lazily populated.
+	// TODO(thepudds): consider adding a field on ir.Func instead. We might also be able
+	// to use that field elsewhere, like in walk. See discussion in https://go.dev/cl/688075.
+	reassignOracles := make(map[*ir.Func]*ir.ReassignOracle)
+
+	ir.VisitFuncsBottomUp(all, func(list []*ir.Func, recursive bool) {
+		Batch(list, reassignOracles)
+	})
 }
 
 // Batch performs escape analysis on a minimal batch of
 // functions.
-func Batch(fns []*ir.Func, recursive bool) {
+func Batch(fns []*ir.Func, reassignOracles map[*ir.Func]*ir.ReassignOracle) {
 	var b batch
 	b.heapLoc.attrs = attrEscapes | attrPersists | attrMutates | attrCalls
 	b.mutatorLoc.attrs = attrMutates
 	b.calleeLoc.attrs = attrCalls
-	b.reassignOracles = make(map[*ir.Func]*ir.ReassignOracle)
+	b.reassignOracles = reassignOracles
 
 	// Construct data-flow graph from syntax trees.
 	for _, fn := range fns {
@@ -531,19 +538,9 @@ func (b *batch) rewriteWithLiterals(n ir.Node, fn *ir.Func) {
 	if n == nil || fn == nil {
 		return
 	}
-	if n.Op() != ir.OMAKESLICE && n.Op() != ir.OCONVIFACE {
-		return
-	}
 
-	// Look up a cached ReassignOracle for the function, lazily computing one if needed.
-	ro := b.reassignOracle(fn)
-	if ro == nil {
-		base.Fatalf("no ReassignOracle for function %v with closure parent %v", fn, fn.ClosureParent)
-	}
-
-	assignTemp := func(n ir.Node, init *ir.Nodes) {
+	assignTemp := func(pos src.XPos, n ir.Node, init *ir.Nodes) {
 		// Preserve any side effects of n by assigning it to an otherwise unused temp.
-		pos := n.Pos()
 		tmp := typecheck.TempAt(pos, fn, n.Type())
 		init.Append(typecheck.Stmt(ir.NewDecl(pos, ir.ODCL, tmp)))
 		init.Append(typecheck.Stmt(ir.NewAssignStmt(pos, tmp, n)))
@@ -561,6 +558,11 @@ func (b *batch) rewriteWithLiterals(n ir.Node, fn *ir.Func) {
 		}
 
 		if (*r).Op() != ir.OLITERAL {
+			// Look up a cached ReassignOracle for the function, lazily computing one if needed.
+			ro := b.reassignOracle(fn)
+			if ro == nil {
+				base.Fatalf("no ReassignOracle for function %v with closure parent %v", fn, fn.ClosureParent)
+			}
 			if s := ro.StaticValue(*r); s.Op() == ir.OLITERAL {
 				lit, ok := s.(*ir.BasicLit)
 				if !ok || lit.Val().Kind() != constant.Int {
@@ -572,8 +574,8 @@ func (b *batch) rewriteWithLiterals(n ir.Node, fn *ir.Func) {
 						return
 					}
 					// Preserve any side effects of the original expression, then replace it.
-					assignTemp(*r, n.PtrInit())
-					*r = lit
+					assignTemp(n.Pos(), *r, n.PtrInit())
+					*r = ir.NewBasicLit(n.Pos(), (*r).Type(), lit.Val())
 				}
 			}
 		}
@@ -582,6 +584,12 @@ func (b *batch) rewriteWithLiterals(n ir.Node, fn *ir.Func) {
 		// a literal to avoid heap allocating the underlying interface value.
 		conv := n.(*ir.ConvExpr)
 		if conv.X.Op() != ir.OLITERAL && !conv.X.Type().IsInterface() {
+			// TODO(thepudds): likely could avoid some work by tightening the check of conv.X's type.
+			// Look up a cached ReassignOracle for the function, lazily computing one if needed.
+			ro := b.reassignOracle(fn)
+			if ro == nil {
+				base.Fatalf("no ReassignOracle for function %v with closure parent %v", fn, fn.ClosureParent)
+			}
 			v := ro.StaticValue(conv.X)
 			if v != nil && v.Op() == ir.OLITERAL && ir.ValidTypeForConst(conv.X.Type(), v.Val()) {
 				if !base.LiteralAllocHash.MatchPos(n.Pos(), nil) {
@@ -592,9 +600,9 @@ func (b *batch) rewriteWithLiterals(n ir.Node, fn *ir.Func) {
 					base.WarnfAt(n.Pos(), "rewriting OCONVIFACE value from %v (%v) to %v (%v)", conv.X, conv.X.Type(), v, v.Type())
 				}
 				// Preserve any side effects of the original expression, then replace it.
-				assignTemp(conv.X, conv.PtrInit())
+				assignTemp(conv.Pos(), conv.X, conv.PtrInit())
 				v := v.(*ir.BasicLit)
-				conv.X = ir.NewBasicLit(conv.X.Pos(), conv.X.Type(), v.Val())
+				conv.X = ir.NewBasicLit(conv.Pos(), conv.X.Type(), v.Val())
 				typecheck.Expr(conv)
 			}
 		}

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

@@ -41,6 +41,9 @@ type FuncDebug struct {
 	RegOutputParams []*ir.Name
 	// Variable declarations that were removed during optimization
 	OptDcl []*ir.Name
+	// The ssa.Func.EntryID value, used to build location lists for
+	// return values promoted to heap in later DWARF generation.
+	EntryID ID
 
 	// Filled in by the user. Translates Block and Value ID to PC.
 	//
@@ -1645,13 +1648,13 @@ func readPtr(ctxt *obj.Link, buf []byte) uint64 {
 
 }
 
-// setupLocList creates the initial portion of a location list for a
+// SetupLocList creates the initial portion of a location list for a
 // user variable. It emits the encoded start/end of the range and a
 // placeholder for the size. Return value is the new list plus the
 // slot in the list holding the size (to be updated later).
-func setupLocList(ctxt *obj.Link, f *Func, list []byte, st, en ID) ([]byte, int) {
-	start, startOK := encodeValue(ctxt, f.Entry.ID, st)
-	end, endOK := encodeValue(ctxt, f.Entry.ID, en)
+func SetupLocList(ctxt *obj.Link, entryID ID, list []byte, st, en ID) ([]byte, int) {
+	start, startOK := encodeValue(ctxt, entryID, st)
+	end, endOK := encodeValue(ctxt, entryID, en)
 	if !startOK || !endOK {
 		// This could happen if someone writes a function that uses
 		// >65K values on a 32-bit platform. Hopefully a degraded debugging
@@ -1800,7 +1803,6 @@ func isNamedRegParam(p abi.ABIParamAssignment) bool {
 // appropriate for the ".closureptr" compiler-synthesized variable
 // needed by the debugger for range func bodies.
 func BuildFuncDebugNoOptimized(ctxt *obj.Link, f *Func, loggingEnabled bool, stackOffset func(LocalSlot) int32, rval *FuncDebug) {
-
 	needCloCtx := f.CloSlot != nil
 	pri := f.ABISelf.ABIAnalyzeFuncType(f.Type)
 
@@ -1911,7 +1913,7 @@ func BuildFuncDebugNoOptimized(ctxt *obj.Link, f *Func, loggingEnabled bool, sta
 		// Param is arriving in one or more registers. We need a 2-element
 		// location expression for it. First entry in location list
 		// will correspond to lifetime in input registers.
-		list, sizeIdx := setupLocList(ctxt, f, rval.LocationLists[pidx],
+		list, sizeIdx := SetupLocList(ctxt, f.Entry.ID, rval.LocationLists[pidx],
 			BlockStart.ID, afterPrologVal)
 		if list == nil {
 			pidx++
@@ -1961,7 +1963,7 @@ func BuildFuncDebugNoOptimized(ctxt *obj.Link, f *Func, loggingEnabled bool, sta
 
 		// Second entry in the location list will be the stack home
 		// of the param, once it has been spilled.  Emit that now.
-		list, sizeIdx = setupLocList(ctxt, f, list,
+		list, sizeIdx = SetupLocList(ctxt, f.Entry.ID, list,
 			afterPrologVal, FuncEnd.ID)
 		if list == nil {
 			pidx++

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

@@ -115,6 +115,34 @@ func TestDebugLines_53456(t *testing.T) {
 	testDebugLinesDefault(t, "-N -l", "b53456.go", "(*T).Inc", []int{15, 16, 17, 18}, true)
 }
 
+func TestDebugLines_74576(t *testing.T) {
+	unixOnly(t)
+
+	switch testGoArch() {
+	default:
+		// Failed on linux/riscv64 (issue 74669), but conservatively
+		// skip many architectures like several other tests here.
+		t.Skip("skipped for many architectures")
+
+	case "arm64", "amd64", "loong64":
+		tests := []struct {
+			file      string
+			wantStmts []int
+		}{
+			{"i74576a.go", []int{12, 13, 13, 14}},
+			{"i74576b.go", []int{12, 13, 13, 14}},
+			{"i74576c.go", []int{12, 13, 13, 14}},
+		}
+		t.Parallel()
+		for _, test := range tests {
+			t.Run(test.file, func(t *testing.T) {
+				t.Parallel()
+				testDebugLines(t, "-N -l", test.file, "main", test.wantStmts, false)
+			})
+		}
+	}
+}
+
 func compileAndDump(t *testing.T, file, function, moreGCFlags string) []byte {
 	testenv.MustHaveGoBuild(t)
 
@@ -223,6 +251,9 @@ func testInlineStack(t *testing.T, file, function string, wantStacks [][]int) {
 // then verifies that the statement-marked lines in that file are the same as those in wantStmts
 // These files must all be short because this is super-fragile.
 // "go build" is run in a temporary directory that is normally deleted, unless -test.v
+//
+// TODO: the tests calling this are somewhat expensive; perhaps more tests can be marked t.Parallel,
+// or perhaps the mechanism here can be made more efficient.
 func testDebugLines(t *testing.T, gcflags, file, function string, wantStmts []int, ignoreRepeats bool) {
 	dumpBytes := compileAndDump(t, file, function, gcflags)
 	dump := bufio.NewScanner(bytes.NewReader(dumpBytes))

src/cmd/compile/internal/ssa/testdata/i74576a.go

@@ -0,0 +1,17 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"runtime"
+)
+
+func main() {
+	a := 1
+	runtime.Breakpoint()
+	sink = a
+}
+
+var sink any

src/cmd/compile/internal/ssa/testdata/i74576b.go

@@ -0,0 +1,15 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"runtime"
+)
+
+func main() {
+	a := 1
+	runtime.Breakpoint()
+	_ = make([]int, a)
+}

src/cmd/compile/internal/ssa/testdata/i74576c.go

@@ -0,0 +1,19 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"runtime"
+)
+
+func main() {
+	s := S{1, 1}
+	runtime.Breakpoint()
+	sink = s
+}
+
+type S struct{ a, b uint64 }
+
+var sink any

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

@@ -7611,6 +7611,9 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 	if base.Ctxt.Flag_locationlists {
 		var debugInfo *ssa.FuncDebug
 		debugInfo = e.curfn.DebugInfo.(*ssa.FuncDebug)
+		// Save off entry ID in case we need it later for DWARF generation
+		// for return values promoted to the heap.
+		debugInfo.EntryID = f.Entry.ID
 		if e.curfn.ABI == obj.ABIInternal && base.Flag.N != 0 {
 			ssa.BuildFuncDebugNoOptimized(base.Ctxt, f, base.Debug.LocationLists > 1, StackOffset, debugInfo)
 		} else {

src/cmd/compile/internal/types2/builtins.go

@@ -91,22 +91,25 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 		// to type []byte with a second argument of string type followed by ... .
 		// This form appends the bytes of the string."
 
-		// get special case out of the way
+		// Handle append(bytes, y...) special case, where
+		// the type set of y is {string} or {string, []byte}.
 		var sig *Signature
 		if nargs == 2 && hasDots(call) {
 			if ok, _ := x.assignableTo(check, NewSlice(universeByte), nil); ok {
 				y := args[1]
+				hasString := false
 				typeset(y.typ, func(_, u Type) bool {
 					if s, _ := u.(*Slice); s != nil && Identical(s.elem, universeByte) {
 						return true
 					}
 					if isString(u) {
+						hasString = true
 						return true
 					}
 					y = nil
 					return false
 				})
-				if y != nil {
+				if y != nil && hasString {
 					// setting the signature also signals that we're done
 					sig = makeSig(x.typ, x.typ, y.typ)
 					sig.variadic = true

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

@@ -62,11 +62,11 @@ var Go = &Command{
 // Lookup returns the subcommand with the given name, if any.
 // Otherwise it returns nil.
 //
-// Lookup ignores subcommands that have len(c.Commands) == 0 and c.Run == nil.
+// Lookup ignores any subcommand `sub` that has len(sub.Commands) == 0 and sub.Run == nil.
 // Such subcommands are only for use as arguments to "help".
 func (c *Command) Lookup(name string) *Command {
 	for _, sub := range c.Commands {
-		if sub.Name() == name && (len(c.Commands) > 0 || c.Runnable()) {
+		if sub.Name() == name && (len(sub.Commands) > 0 || sub.Runnable()) {
 			return sub
 		}
 	}