Merge pull request #21 from golang/master

[pull] master from golang:master

Author: pull[bot]

api/next/77363.txt

@@ -0,0 +1 @@
+pkg crypto/tls, type QUICConfig struct, ClientHelloInfoConn net.Conn #77363

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

@@ -0,0 +1,2 @@
+The new [QUICConfig.ClientHelloInfoConn] field specifies the [net.Conn] to use
+for the [ClientHelloInfo.Conn] field during QUIC server handshakes.

doc/next/6-stdlib/99-minor/net/http/21753.md

@@ -0,0 +1,3 @@
+[Transport] and [Server] support TLS ALPN protocol negotiation on
+user-provided [net.Conn] connections which implement a
+`ConnectionState() tls.ConnectionState` method.

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

@@ -700,11 +700,33 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 	case ssa.OpAMD64SUBQconst, ssa.OpAMD64SUBLconst,
 		ssa.OpAMD64ANDLconst,
 		ssa.OpAMD64ORQconst, ssa.OpAMD64ORLconst,
-		ssa.OpAMD64XORQconst, ssa.OpAMD64XORLconst,
-		ssa.OpAMD64SHLQconst, ssa.OpAMD64SHLLconst,
+		ssa.OpAMD64XORQconst, ssa.OpAMD64XORLconst:
+		p := s.Prog(v.Op.Asm())
+		p.From.Type = obj.TYPE_CONST
+		p.From.Offset = v.AuxInt
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = v.Reg()
+
+	case ssa.OpAMD64SHLQconst, ssa.OpAMD64SHLLconst,
 		ssa.OpAMD64SHRQconst, ssa.OpAMD64SHRLconst, ssa.OpAMD64SHRWconst, ssa.OpAMD64SHRBconst,
 		ssa.OpAMD64SARQconst, ssa.OpAMD64SARLconst, ssa.OpAMD64SARWconst, ssa.OpAMD64SARBconst,
 		ssa.OpAMD64ROLQconst, ssa.OpAMD64ROLLconst, ssa.OpAMD64ROLWconst, ssa.OpAMD64ROLBconst:
+		var maxShift int64
+		switch v.Op {
+		case ssa.OpAMD64SHLQconst, ssa.OpAMD64SHRQconst, ssa.OpAMD64SARQconst, ssa.OpAMD64ROLQconst:
+			maxShift = 63
+		case ssa.OpAMD64SHLLconst, ssa.OpAMD64SHRLconst, ssa.OpAMD64SARLconst, ssa.OpAMD64ROLLconst:
+			maxShift = 31
+		case ssa.OpAMD64SHRWconst, ssa.OpAMD64SARWconst, ssa.OpAMD64ROLWconst:
+			maxShift = 15
+		case ssa.OpAMD64SHRBconst, ssa.OpAMD64SARBconst, ssa.OpAMD64ROLBconst:
+			maxShift = 7
+		default:
+			panic("unreachable")
+		}
+		if v.AuxInt < 0 || v.AuxInt > maxShift {
+			v.Fatalf("shift amount out of range [0,%d]: %d", maxShift, v.AuxInt)
+		}
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_CONST
 		p.From.Offset = v.AuxInt

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

@@ -324,9 +324,9 @@ func CanInline(fn *ir.Func, profile *pgoir.Profile) {
 // function is inlinable.
 func noteInlinableFunc(n *ir.Name, fn *ir.Func, cost int32) {
 	if base.Flag.LowerM > 1 {
-		fmt.Printf("%v: can inline %v with cost %d as: %v { %v }\n", ir.Line(fn), n, cost, fn.Type(), fn.Body)
+		fmt.Printf("%v: can inline %v with cost %d as: %v { %v }\n", ir.Line(fn), n.DiagName(), cost, fn.Type(), fn.Body)
 	} else if base.Flag.LowerM != 0 {
-		fmt.Printf("%v: can inline %v\n", ir.Line(fn), n)
+		fmt.Printf("%v: can inline %v\n", ir.Line(fn), n.DiagName())
 	}
 	// JSON optimization log output.
 	if logopt.Enabled() {
@@ -1252,9 +1252,9 @@ func mkinlcall(callerfn *ir.Func, n *ir.CallExpr, fn *ir.Func, bigCaller, closur
 	if base.Flag.LowerM != 0 {
 		if buildcfg.Experiment.NewInliner {
 			fmt.Printf("%v: inlining call to %v with score %d\n",
-				ir.Line(n), fn, score)
+				ir.Line(n), fn.Nname.DiagName(), score)
 		} else {
-			fmt.Printf("%v: inlining call to %v\n", ir.Line(n), fn)
+			fmt.Printf("%v: inlining call to %v\n", ir.Line(n), fn.Nname.DiagName())
 		}
 	}
 	if base.Flag.LowerM > 2 {
@@ -1264,7 +1264,7 @@ func mkinlcall(callerfn *ir.Func, n *ir.CallExpr, fn *ir.Func, bigCaller, closur
 	res := InlineCall(callerfn, n, fn, inlIndex)
 
 	if res == nil {
-		base.FatalfAt(n.Pos(), "inlining call to %v failed", fn)
+		base.FatalfAt(n.Pos(), "inlining call to %v failed", fn.Nname.DiagName())
 	}
 
 	if base.Flag.LowerM > 2 {

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

@@ -7,11 +7,13 @@ package ir
 import (
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/types"
+	"cmd/internal/hash"
 	"cmd/internal/obj"
 	"cmd/internal/objabi"
 	"cmd/internal/src"
+	"encoding/base64"
 	"fmt"
-	"strings"
+	"io"
 	"unicode/utf8"
 )
 
@@ -430,10 +432,9 @@ func ClosureDebugRuntimeCheck(clo *ClosureExpr) {
 var globClosgen int32
 
 // closureName generates a new unique name for a closure within outerfn at pos.
-func closureName(outerfn *Func, pos src.XPos, why Op) *types.Sym {
-	if outerfn.OClosure != nil && outerfn.OClosure.Func.RangeParent != nil {
-		outerfn = outerfn.OClosure.Func.RangeParent
-	}
+// gen is an optional counter for the closure name. If it is 0, the counter
+// will be computed based on outerfn.
+func closureName(outerfn *Func, pos src.XPos, why Op, gen int) *types.Sym {
 	pkg := types.LocalPkg
 	outer := "glob."
 	var suffix string = "."
@@ -451,38 +452,64 @@ func closureName(outerfn *Func, pos src.XPos, why Op) *types.Sym {
 	case ODEFER:
 		suffix = ".deferwrap"
 	}
-	gen := &globClosgen
 
 	// There may be multiple functions named "_". In those
 	// cases, we can't use their individual Closgens as it
 	// would lead to name clashes.
 	if !IsBlank(outerfn.Nname) {
 		pkg = outerfn.Sym().Pkg
 		outer = FuncName(outerfn)
-
-		switch why {
-		case OCLOSURE:
-			gen = &outerfn.funcLitGen
-		case ORANGE:
-			gen = &outerfn.rangeLitGen
-		default:
-			gen = &outerfn.goDeferGen
-		}
 	}
 
-	// If this closure was created due to inlining, then incorporate any
-	// inlined functions' names into the closure's linker symbol name
-	// too (#60324).
+	// If this closure was created due to inlining, find the original
+	// outer function's name for the closure (#60324).
+	var inlHash string
 	if inlIndex := base.Ctxt.InnermostPos(pos).Base().InliningIndex(); inlIndex >= 0 {
-		names := []string{outer}
+		// The compiler doesn't like multiple symbols with the same
+		// name. We make a unique suffix temporarily for the
+		// compiler, and strip it during object file writing, so
+		// it will not be the linker symbol name. For linking,
+		// we use a content hash to disambiguate instead.
+		// We choose the suffix as a hash of the inline call stack.
+		h := hash.New32()
+		io.WriteString(h, outer)
 		base.Ctxt.InlTree.AllParents(inlIndex, func(call obj.InlinedCall) {
-			names = append(names, call.Name)
+			io.WriteString(h, call.Name+":"+call.Pos.LineNumber()+":"+call.Pos.ColumnNumber())
 		})
-		outer = strings.Join(names, ".")
+		inlHash = base64.StdEncoding.EncodeToString(h.Sum(nil)[:8])
+
+		outer = base.Ctxt.InlTree.InlinedFuncName(inlIndex)
+		if pkgPath := base.Ctxt.InlTree.InlinedFuncPkg(inlIndex); pkgPath != "" {
+			pkg = types.NewPkg(pkgPath, "")
+		}
 	}
 
-	*gen++
-	return pkg.Lookup(fmt.Sprintf("%s%s%d", outer, suffix, *gen))
+	if gen == 0 {
+		p := &globClosgen
+		if !IsBlank(outerfn.Nname) {
+			switch why {
+			case OCLOSURE:
+				p = &outerfn.funcLitGen
+			case ORANGE:
+				p = &outerfn.rangeLitGen
+			default:
+				p = &outerfn.goDeferGen
+			}
+		}
+		*p++
+		gen = int(*p)
+	}
+
+	name := fmt.Sprintf("%s%s%d", outer, suffix, gen)
+	if inlHash != "" {
+		// Attach the inline hash (see the comment above).
+		// If it already has a hash, trim it, so we don't include
+		// two hashes for nested closures. The new hash should be
+		// enough to disambiguate.
+		name = obj.TrimInlineHash(name) + "#" + inlHash + "#"
+	}
+
+	return pkg.Lookup(name)
 }
 
 // NewClosureFunc creates a new Func to represent a function literal
@@ -500,14 +527,19 @@ func closureName(outerfn *Func, pos src.XPos, why Op) *types.Sym {
 // why is the reason we're generating this Func. It can be OCLOSURE
 // (for a normal function literal) or OGO or ODEFER (for wrapping a
 // call expression that has parameters or results).
-func NewClosureFunc(fpos, cpos src.XPos, why Op, typ *types.Type, outerfn *Func, pkg *Package) *Func {
+//
+// gen is an optional counter for the closure name. If it is 0,
+// the counter will be computed based on outerfn.
+func NewClosureFunc(fpos, cpos src.XPos, why Op, typ *types.Type, outerfn *Func, pkg *Package, gen int) *Func {
 	if outerfn == nil {
 		base.FatalfAt(fpos, "outerfn is nil")
 	}
 
-	fn := NewFunc(fpos, fpos, closureName(outerfn, cpos, why), typ)
+	fn := NewFunc(fpos, fpos, closureName(outerfn, cpos, why, gen), typ)
 	fn.SetDupok(outerfn.Dupok()) // if the outer function is dupok, so is the closure
 
+	fn.Linksym().Set(obj.AttrContentAddressable, true)
+
 	clo := &ClosureExpr{Func: fn}
 	clo.op = OCLOSURE
 	clo.pos = cpos

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

@@ -167,6 +167,10 @@ func (*Name) CanBeNtype()    {}
 func (*Name) CanBeAnSSASym() {}
 func (*Name) CanBeAnSSAAux() {}
 
+// DiagName returns the symbol name for diagnostics.
+// XXX should it be part of the formatter?
+func (n *Name) DiagName() string { return obj.TrimInlineHash(fmt.Sprint(n.Sym())) }
+
 // Pragma returns the PragmaFlag for p, which must be for an OTYPE.
 func (n *Name) Pragma() PragmaFlag { return n.pragma }
 

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

@@ -100,6 +100,11 @@ type reader struct {
 
 	dict *readerDict
 
+	// funcLitGen is a counter for closure names.
+	funcLitGen int
+	// rangeLitGen is a counter for range func closure names.
+	rangeLitGen int
+
 	// TODO(mdempsky): The state below is all specific to reading
 	// function bodies. It probably makes sense to split it out
 	// separately so that it doesn't take up space in every reader
@@ -3307,8 +3312,17 @@ func (r *reader) inlClosureFunc(origPos src.XPos, sig *types.Type, why ir.Op) *i
 		curfn = r.curfn
 	}
 
+	var gen int
+	if why == ir.ORANGE {
+		r.rangeLitGen++
+		gen = r.rangeLitGen
+	} else {
+		r.funcLitGen++
+		gen = r.funcLitGen
+	}
+
 	// TODO(mdempsky): Remove hard-coding of typecheck.Target.
-	return ir.NewClosureFunc(origPos, r.inlPos(origPos), why, sig, curfn, typecheck.Target)
+	return ir.NewClosureFunc(origPos, r.inlPos(origPos), why, sig, curfn, typecheck.Target, gen)
 }
 
 func (r *reader) exprList() []ir.Node {

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

@@ -912,7 +912,8 @@
 (LEA(Q|L)2 [0] {s} (ADD(Q|L) x x) x) && s == nil => (SHL(Q|L)const [2] x)
 
 // (x + x) << 2 -> x << 3 and similar
-(SHL(Q|L)const [c] (ADD(Q|L) x x))  => (SHL(Q|L)const [c+1] x)
+(SHLQconst [c] (ADDQ x x)) && c < 63 => (SHLQconst [c+1] x)
+(SHLLconst [c] (ADDL x x)) && c < 31 => (SHLLconst [c+1] x)
 
 // reverse ordering of compare instruction
 (SETL (InvertFlags x)) => (SETG x)