[pull] master from golang:master

api/next/78543.txt

@@ -0,0 +1,2 @@
+pkg crypto/tls, const MLKEM1024 = 514 #78543
+pkg crypto/tls, const MLKEM1024 CurveID #78543

api/next/79367.txt

@@ -0,0 +1 @@
+pkg crypto/tls, type Config struct, Rand //deprecated #79367

doc/godebug.md

@@ -158,6 +158,16 @@ and the [go command documentation](/cmd/go#hdr-Build_and_test_caching).
 
 Go 1.27 removed the `gotypesalias` setting, as noted in the [Go 1.22](#go-122) section.
 
+Go 1.27 removed the `tlsunsafeekm` setting, as noted in the [Go 1.22](#go-122) section.
+
+Go 1.27 removed the `tlsrsakex` setting, as noted in the [Go 1.22](#go-122) section.
+
+Go 1.27 removed the `tls3des` setting, as noted in the [Go 1.23](#go-123) section.
+
+Go 1.27 removed the `tls10server` setting, as noted in the [Go 1.22](#go-122) section.
+
+Go 1.27 removed the `x509keypairleaf` setting, as noted in the [Go 1.23](#go-123) section.
+
 Go 1.27 added a new `htmlmetacontenturlescape` setting that controls whether
 html/template will escape URLs in the `url=` portion of the content attribute of
 HTML meta tags. The default `htmlmetacontentescape=1` will cause URLs to be

doc/next/6-stdlib/99-minor/crypto/ecdsa/hashlen.md

@@ -0,0 +1,2 @@
+[PrivateKey.Sign] now checks that the length of the hash is correct, if opts is
+not nil.

doc/next/6-stdlib/99-minor/crypto/tls/78543.md

@@ -0,0 +1,2 @@
+The [MLKEM1024] key exchange is now supported. It can be enabled by adding it to
+[Config.CurvePreferences].

doc/next/6-stdlib/99-minor/crypto/tls/79367.md

@@ -0,0 +1,2 @@
+[Config.Rand] is now deprecated.
+For deterministic testing, use [testing/cryptotest.SetGlobalRandom].

doc/next/6-stdlib/99-minor/crypto/tls/tlsmlkem.md

@@ -0,0 +1,4 @@
+Post-quantum hybrid key exchanges can now be explicitly enabled in
+[Config.CurvePreferences] even if the `tlsmlkem=0` or `tlssecpmlkem=0` GODEBUG
+options are used. Those options were always meant to only apply to the default
+set used when [Config.CurvePreferences] is nil.

doc/next/7-ports.md

@@ -6,3 +6,13 @@
 As [announced](go1.26#darwin) in the Go 1.26 release notes,
 Go 1.27 requires macOS 13 Ventura or later;
 support for previous versions has been discontinued.
+
+### Linux {#linux}
+<!-- go.dev/issue/76244 -->
+On ppc64, the ABI has been migrated to ELFv2. This change
+has no effect for those building and running pure Go
+binaries.
+
+On ppc64, external linking, cgo, and PIE binaries are now
+supported. Using these features requires an ELFv2 compatible
+runtime (libc, kernel, and all linked and loaded libraries).

src/cmd/api/main_test.go

@@ -389,7 +389,7 @@ func (w *Walker) parseFile(dir, file string) (*ast.File, error) {
 		return f, nil
 	}
 
-	f, err := parser.ParseFile(fset, filename, nil, parser.ParseComments)
+	f, err := parser.ParseFile(fset, filename, nil, parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		return nil, err
 	}

src/cmd/cgo/internal/testerrors/argposition_test.go

@@ -96,7 +96,7 @@ func TestArgumentsPositions(t *testing.T) {
 		t.Fatal(err)
 	}
 	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, "", mainProcessed, parser.AllErrors)
+	f, err := parser.ParseFile(fset, "", mainProcessed, parser.AllErrors|parser.SkipObjectResolution)
 	if err != nil {
 		fmt.Println(err)
 		return

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

@@ -175,6 +175,10 @@ type pragmas struct {
 	WasmExport *WasmExport
 }
 
+func (p *pragmas) Nointerface() bool {
+	return p.Flag&ir.Nointerface != 0
+}
+
 // WasmImport stores metadata associated with the //go:wasmimport pragma
 type WasmImport struct {
 	Pos    syntax.Pos

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

@@ -289,7 +289,7 @@ func genRulesSuffix(arch arch, suff string) {
 	buf := new(bytes.Buffer)
 	fprint(buf, genFile)
 	fset := token.NewFileSet()
-	file, err := parser.ParseFile(fset, "", buf, parser.ParseComments)
+	file, err := parser.ParseFile(fset, "", buf, parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		filename := fmt.Sprintf("%s_broken.go", arch.name)
 		if err := os.WriteFile(filename, buf.Bytes(), 0644); err != nil {
@@ -841,7 +841,7 @@ func exprf(format string, a ...interface{}) ast.Expr {
 func stmtf(format string, a ...interface{}) Statement {
 	src := fmt.Sprintf(format, a...)
 	fsrc := "package p\nfunc _() {\n" + src + "\n}\n"
-	file, err := parser.ParseFile(token.NewFileSet(), "", fsrc, 0)
+	file, err := parser.ParseFile(token.NewFileSet(), "", fsrc, parser.SkipObjectResolution)
 	if err != nil {
 		log.Fatalf("stmt parse error on %q: %v", src, err)
 	}

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

@@ -280,6 +280,10 @@ func makeABIWrapper(f *ir.Func, wrapperABI obj.ABI) {
 	fn.SetABIWrapper(true)
 	fn.SetDupok(true)
 
+	// Propagate linkname attribute.
+	fn.LinksymABI(fn.ABI).Set(obj.AttrLinkname, f.Linksym().IsLinkname())
+	fn.LinksymABI(fn.ABI).Set(obj.AttrLinknameStd, f.Linksym().IsLinknameStd())
+
 	// ABI0-to-ABIInternal wrappers will be mainly loading params from
 	// stack into registers (and/or storing stack locations back to
 	// registers after the wrapped call); in most cases they won't

src/cmd/compile/internal/test/ssa_test.go

@@ -95,7 +95,7 @@ func TestCode(t *testing.T) {
 			t.Fatalf("can't read testdata/%s: %v", f.Name(), err)
 		}
 		fset := token.NewFileSet()
-		code, err := parser.ParseFile(fset, f.Name(), text, 0)
+		code, err := parser.ParseFile(fset, f.Name(), text, parser.SkipObjectResolution)
 		if err != nil {
 			t.Fatalf("can't parse testdata/%s: %v", f.Name(), err)
 		}

src/cmd/compile/internal/typecheck/mkbuiltin.go

@@ -79,7 +79,7 @@ func params(tlist ...*types.Type) []*types.Field {
 
 func mkbuiltin(w io.Writer, name string) {
 	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, filepath.Join("_builtin", name+".go"), nil, 0)
+	f, err := parser.ParseFile(fset, filepath.Join("_builtin", name+".go"), nil, parser.SkipObjectResolution)
 	if err != nil {
 		log.Fatal(err)
 	}

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

@@ -684,6 +684,12 @@ func (check *Checker) funcDecl(obj *Func, decl *declInfo) {
 	fdecl := decl.fdecl
 	check.funcType(sig, fdecl.Recv, fdecl.TParamList, fdecl.Type)
 
+	if fdecl.Pragma != nil {
+		if p, ok := fdecl.Pragma.(interface{ Nointerface() bool }); ok && p.Nointerface() {
+			obj.nointerface = true
+		}
+	}
+
 	// Set the scope's extent to the complete "func (...) { ... }"
 	// so that Scope.Innermost works correctly.
 	sig.scope.pos = fdecl.Pos()

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

@@ -390,6 +390,7 @@ func (check *Checker) missingMethod(V, T Type, static bool, equivalent func(x, y
 		ambigSel
 		ptrRecv
 		field
+		nointerface
 	)
 
 	state := ok
@@ -453,6 +454,11 @@ func (check *Checker) missingMethod(V, T Type, static bool, equivalent func(x, y
 				check.objDecl(f)
 			}
 
+			if f.nointerface {
+				state = nointerface
+				break
+			}
+
 			if !equivalent(f.typ, m.typ) {
 				state = wrongSig
 				break
@@ -512,6 +518,8 @@ func (check *Checker) missingMethod(V, T Type, static bool, equivalent func(x, y
 			*cause = check.sprintf("(method %s has pointer receiver)", m.Name())
 		case field:
 			*cause = check.sprintf("(%s.%s is a field, not a method)", V, m.Name())
+		case nointerface:
+			*cause = check.sprintf("(%s method is marked 'nointerface')", m.Name())
 		default:
 			panic("unreachable")
 		}

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

@@ -396,8 +396,9 @@ func (*Var) isDependency() {} // a variable may be a dependency of an initializa
 // An abstract method may belong to many interfaces due to embedding.
 type Func struct {
 	object
-	hasPtrRecv_ bool  // only valid for methods that don't have a type yet; use hasPtrRecv() to read
 	origin      *Func // if non-nil, the Func from which this one was instantiated
+	hasPtrRecv_ bool  // only valid for methods that don't have a type yet; use hasPtrRecv() to read
+	nointerface bool
 }
 
 // NewFunc returns a new function with the given signature, representing
@@ -412,7 +413,7 @@ func NewFunc(pos syntax.Pos, pkg *Package, name string, sig *Signature) *Func {
 		// as this would violate object.{Type,color} invariants.
 		// TODO(adonovan): propose to disallow NewFunc with nil *Signature.
 	}
-	return &Func{object{nil, pos, pkg, name, typ, 0, nopos}, false, nil}
+	return &Func{object{nil, pos, pkg, name, typ, 0, nopos}, nil, false, false}
 }
 
 // Signature returns the signature (type) of the function or method.

src/cmd/cover/cover.go

@@ -773,7 +773,7 @@ func (p *Package) annotateFile(name string, fd io.Writer) {
 	if err != nil {
 		log.Fatalf("cover: %s: %s", name, err)
 	}
-	parsedFile, err := parser.ParseFile(fset, name, content, parser.ParseComments)
+	parsedFile, err := parser.ParseFile(fset, name, content, parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		log.Fatalf("cover: %s: %s", name, err)
 	}

src/cmd/cover/cover_test.go

@@ -259,7 +259,7 @@ func TestDirectives(t *testing.T) {
 	// come before the beginning of the named declaration and after the end
 	// of the previous declaration.
 	fset := token.NewFileSet()
-	astFile, err := parser.ParseFile(fset, testDirectives, output, 0)
+	astFile, err := parser.ParseFile(fset, testDirectives, output, parser.SkipObjectResolution)
 	if err != nil {
 		t.Fatal(err)
 	}

src/cmd/cover/func.go

@@ -93,7 +93,7 @@ func funcOutput(profile, outputFile string) error {
 // findFuncs parses the file and returns a slice of FuncExtent descriptors.
 func findFuncs(name string) ([]*FuncExtent, error) {
 	fset := token.NewFileSet()
-	parsedFile, err := parser.ParseFile(fset, name, nil, 0)
+	parsedFile, err := parser.ParseFile(fset, name, nil, parser.SkipObjectResolution)
 	if err != nil {
 		return nil, err
 	}

src/cmd/dist/testjson.go

@@ -80,7 +80,8 @@ func (f *testJSONFilter) process(line []byte) {
 		// struct, or other additions outside of it. If humans are ever looking
 		// at the output, it's really nice to keep field order because it
 		// preserves a lot of regularity in the output.
-		dec := json.NewDecoder(bytes.NewBuffer(line))
+		lineBuf := bytes.NewBuffer(line)
+		dec := json.NewDecoder(lineBuf)
 		dec.UseNumber()
 		val, err := decodeJSONValue(dec)
 		if err == nil && val.atom == json.Delim('{') {
@@ -105,6 +106,7 @@ func (f *testJSONFilter) process(line []byte) {
 				// Copy any trailing text. We expect at most a "\n" here, but
 				// there could be other text and we want to feed that through.
 				io.Copy(f.w, dec.Buffered())
+				io.Copy(f.w, lineBuf)
 				return
 			}
 		}

src/cmd/go/internal/generate/generate.go

@@ -244,7 +244,7 @@ func generate(absFile string) bool {
 	}
 
 	// Parse package clause
-	filePkg, err := parser.ParseFile(token.NewFileSet(), "", src, parser.PackageClauseOnly)
+	filePkg, err := parser.ParseFile(token.NewFileSet(), "", src, parser.PackageClauseOnly|parser.SkipObjectResolution)
 	if err != nil {
 		// Invalid package clause - ignore file.
 		return true

src/cmd/go/internal/modindex/build_read.go

@@ -304,7 +304,7 @@ func readGoInfo(f io.Reader, info *fileInfo) error {
 	}
 
 	// Parse file header & record imports.
-	info.parsed, info.parseErr = parser.ParseFile(info.fset, info.name, info.header, parser.ImportsOnly|parser.ParseComments)
+	info.parsed, info.parseErr = parser.ParseFile(info.fset, info.name, info.header, parser.ImportsOnly|parser.ParseComments|parser.SkipObjectResolution)
 	if info.parseErr != nil {
 		return nil
 	}

src/cmd/gofmt/gofmt.go

@@ -79,7 +79,7 @@ func usage() {
 }
 
 func initParserMode() {
-	parserMode = parser.ParseComments
+	parserMode = parser.ParseComments | parser.SkipObjectResolution
 	if *allErrors {
 		parserMode |= parser.AllErrors
 	}

src/cmd/internal/dwarf/putvarabbrevgen_test.go

@@ -80,7 +80,7 @@ func TestPutVarAbbrevGenerator(t *testing.T) {
 
 func pvagenerate(t *testing.T) string {
 	var fset token.FileSet
-	f, err := parser.ParseFile(&fset, "./dwarf.go", nil, parser.ParseComments)
+	f, err := parser.ParseFile(&fset, "./dwarf.go", nil, parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		t.Fatal(err)
 	}

src/cmd/internal/goobj/mkbuiltin.go

@@ -53,7 +53,7 @@ func mkbuiltin(w io.Writer) {
 	const pkg = "runtime"
 	fset := token.NewFileSet()
 	path := filepath.Join("..", "..", "compile", "internal", "typecheck", "_builtin", "runtime.go")
-	f, err := parser.ParseFile(fset, path, nil, 0)
+	f, err := parser.ParseFile(fset, path, nil, parser.SkipObjectResolution)
 	if err != nil {
 		log.Fatal(err)
 	}

src/cmd/internal/obj/objfile.go

@@ -371,9 +371,7 @@ func (w *writer) Sym(s *LSym) {
 	if s.IsPkgInit() {
 		flag2 |= goobj.SymFlagPkgInit
 	}
-	if s.IsLinkname() || (w.ctxt.IsAsm && name != "") || name == "main.main" {
-		// Assembly reference is treated the same as linkname,
-		// but not for unnamed (aux) symbols.
+	if s.IsLinkname() || name == "main.main" {
 		// The runtime linknames main.main.
 		flag2 |= goobj.SymFlagLinkname
 	}

src/cmd/internal/obj/x86/asm6.go

@@ -2265,7 +2265,16 @@ func instinit(ctxt *obj.Link) {
 
 	switch ctxt.Headtype {
 	case objabi.Hplan9:
+		// _privates is a special symbol on Plan 9 that
+		// points to per–process private data (like TLS area).
+		// See https://9p.io/magic/man2html/2/exec .
+		// The assembler inserts a reference to this symbol
+		// for accessing the G. Mark it as linkname so it is
+		// allowed to access from anywhere. (Would be nice to
+		// mark it external, but we don't have a mechanism for
+		// that.)
 		plan9privates = ctxt.Lookup("_privates")
+		plan9privates.Set(obj.AttrLinkname, true)
 	}
 
 	for i := range avxOptab {

src/cmd/link/internal/loader/loader.go

@@ -15,6 +15,7 @@ import (
 	"debug/elf"
 	"fmt"
 	"internal/abi"
+	"internal/buildcfg"
 	"io"
 	"iter"
 	"log"
@@ -2368,7 +2369,7 @@ func loadObjRefs(l *Loader, r *oReader, arch *sys.Arch) {
 		v := abiToVer(osym.ABI(), r.version)
 		gi := l.LookupOrCreateSym(name, v)
 		r.syms[ndef+i] = gi
-		if osym.IsLinkname() || osym.IsLinknameStd() {
+		if osym.IsLinkname() || osym.IsLinknameStd() || r.FromAssembly() {
 			// Check if a linkname reference is allowed.
 			// Only check references (pull), not definitions (push),
 			// so push is always allowed.
@@ -2426,8 +2427,6 @@ func abiToVer(abi uint16, localSymVersion int) int {
 // If a name is in this map, it is allowed only in listed packages,
 // even if it has a linknamed definition.
 var blockedLinknames = map[string][]string{
-	// coroutines
-	"runtime.newcoro": {"iter"},
 	// fips info
 	"go:fipsinfo": {"crypto/internal/fips140/check"},
 	// New internal linknames in Go 1.24
@@ -2553,19 +2552,36 @@ func (l *Loader) checkLinkname(refpkg *oReader, name string, s Sym) {
 		return
 	}
 	osym := r.Sym(li)
+	if r.FromAssembly() && !osym.IsLinknameStd() && !osym.IsLinkname() {
+		if strings.HasPrefix(name, pkg) {
+			// Allow if by name it is pushed to pkg, e.g. in package a,
+			// an assembly function is defined as b.F, then it is allowed
+			// to be used in package b.
+			return
+		}
+		// For an assembly symbol, check if there is a linkname applied
+		// to its ABI wrapper.
+		if !buildcfg.Experiment.RegabiWrappers {
+			// If ABI wrapper is not enabled (i.e. non-regabi platform),
+			// permit for now, as there is no good way to check.
+			return
+		}
+		otherABI := 1 - abiToVer(osym.ABI(), r.version) // for now, we only have ABI 0 and 1
+		w := l.Lookup(name, otherABI)                   // TODO: use an aux symbol instead of name lookup?
+		if w != 0 {
+			r, li = l.toLocal(w)
+			osym = r.Sym(li)
+		}
+	}
 	if osym.IsLinknameStd() {
 		// It is pushed with linknamestd. Allow only pulls from the
 		// standard library.
 		if refpkg.Std() {
 			return
 		}
 	}
-	if osym.IsLinkname() || osym.ABIWrapper() {
+	if osym.IsLinkname() {
 		// Allow if the def has a linkname (push).
-		// ABI wrapper usually wraps an assembly symbol, a linknamed symbol,
-		// or an external symbol, or provide access of a Go symbol to assembly.
-		// For now, allow ABI wrappers.
-		// TODO: check the wrapped symbol?
 		return
 	}
 	error()

src/cmd/link/link_test.go

@@ -12,6 +12,7 @@ import (
 	"debug/pe"
 	"errors"
 	"internal/abi"
+	"internal/buildcfg"
 	"internal/platform"
 	"internal/testenv"
 	"internal/xcoff"
@@ -1715,6 +1716,10 @@ func TestCheckLinkname(t *testing.T) {
 		{"coro2.go", false},
 		// pull linkname of a builtin symbol is not ok
 		{"builtin.go", false},
+		// using a linkname to reference a runtime assembly
+		// function is not ok (except on non-regabi platforms)
+		{"systemstack.go", !buildcfg.Experiment.RegabiWrappers},
+		// misc
 		{"addmoduledata.go", false},
 		{"freegc.go", false},
 		// legacy bad linkname is ok, for now